@tridion-sites/extensions-cli 0.3.3 → 0.3.5

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # @tridion-sites/extensions-cli
 
+## 0.3.5
+
+### Patch Changes
+
+-   Updated dependencies [81cb87a018]
+-   Updated dependencies [8881ae361a]
+-   Updated dependencies [49558c48b9]
+-   Updated dependencies [31bdf04adf]
+-   Updated dependencies [7a8ec38aa2]
+-   Updated dependencies [06964d8222]
+-   Updated dependencies [282794f3f6]
+-   Updated dependencies [57199c67f2]
+-   Updated dependencies [b803ef7b33]
+-   Updated dependencies [9b78d6d626]
+-   Updated dependencies [31bdf04adf]
+    -   @tridion-sites/extensions@0.5.2
+    -   @tridion-sites/models@0.1.2
+
+## 0.3.4
+
+### Patch Changes
+
+-   2a21aa8c1d: upgrade tinymce
+-   1845a12377: use the latest typescript version
+-   9348205cee: Update of tinyMCE dependency
+-   Updated dependencies [2ea2c9d543]
+-   Updated dependencies [226cc4cce1]
+-   Updated dependencies [1845a12377]
+-   Updated dependencies [9348205cee]
+    -   @tridion-sites/extensions@0.5.1
+    -   @tridion-sites/models@0.1.1
+    -   @tridion-sites/open-api-client@1.0.5
+
 ## 0.3.3
 
 ### Patch Changes

package/dist/addon/template/extension/package.json.hbs

@@ -24,33 +24,41 @@
         "react": "18.2.0",
         "react-dom": "18.2.0",
         "styled-components": "5.3.6",
-        "tinymce": "6.3.1"
+        "tinymce": "6.4.2"
     },
     "devDependencies": {
-        "@babel/core": "7.20.12",
-        "@babel/plugin-transform-runtime": "7.19.6",
-        "@babel/preset-env": "7.20.2",
+        "@babel/core": "7.21.8",
+        "@babel/plugin-transform-runtime": "7.21.4",
+        "@babel/preset-env": "7.21.5",
         "@babel/preset-react": "7.18.6",
-        "@babel/preset-typescript": "7.18.6",
-        "@babel/runtime": "7.20.13",
+        "@babel/preset-typescript": "7.21.5",
+        "@babel/runtime": "7.21.5",
+        "@tridion-sites/extensions": "{{extensionsApiVersion}}",
         "@tridion-sites/extensions-cli": "{{extensionsCliVersion}}",
-        "@types/react": "18.0.27",
-        "@types/react-dom": "18.0.10",
-        "@types/react-is": "17.0.3",
+        "@tridion-sites/models": "{{modelsVersion}}",
+        "@tridion-sites/open-api-client": "{{openApiClientVersion}}",
+        "@types/react": "18.2.6",
+        "@types/react-dom": "18.2.4",
+        "@types/react-is": "18.2.0",
         "@types/styled-components": "5.1.26",
-        "@typescript-eslint/eslint-plugin": "5.45.0",
-        "@typescript-eslint/parser": "5.49.0",
+        "@typescript-eslint/eslint-plugin": "5.59.5",
+        "@typescript-eslint/parser": "5.59.5",
         "babel-loader": "9.1.2",
-        "babel-plugin-styled-components": "2.0.7",
-        "eslint": "8.32.0",
-        "eslint-config-prettier": "8.6.0",
-        "eslint-formatter-pretty": "4.1.0",
-        "eslint-plugin-react": "7.32.1",
+        "babel-plugin-styled-components": "2.1.1",
+        "eslint": "8.40.0",
+        "eslint-config-prettier": "8.8.0",
+        "eslint-formatter-pretty": "5.0.0",
+        "eslint-plugin-react": "7.32.2",
         "eslint-plugin-react-hooks": "4.6.0",
-        "fork-ts-checker-webpack-plugin": "7.3.0",
-        "prettier": "2.8.3",
-        "tsconfig-paths-webpack-plugin": "4.0.0",
-        "typescript": "4.9.4",
+        "fork-ts-checker-webpack-plugin": "8.0.0",
+        "prettier": "2.8.8",
+        "react": "18.2.0",
+        "react-dom": "18.2.0",
+        "react-is": "18.2.0",
+        "styled-components": "5.3.6",
+        "tinymce": "6.4.2",
+        "tsconfig-paths-webpack-plugin": "4.0.1",
+        "typescript": "5.0.4",
         "webpack": "5.82.1",
         "webpack-cli": "5.1.1",
         "webpack-dev-server": "4.15.0"

package/dist/{addonManifest-30c25a45.js → addonManifest-45b9450a.js}

@@ -2,224 +2,224 @@
 import { resolve } from 'node:path';
 import { readFileSync, writeFileSync } from 'node:fs';
 
-const readJsonFile = (path) => {
-    const file = readFileSync(path, { encoding: 'utf-8' });
-    return JSON.parse(file);
-};
-const writeJsonFile = (path, value) => {
-    const json = JSON.stringify(value, null, 4);
-    writeFileSync(path, json);
+const readJsonFile = (path) => {
+    const file = readFileSync(path, { encoding: 'utf-8' });
+    return JSON.parse(file);
+};
+const writeJsonFile = (path, value) => {
+    const json = JSON.stringify(value, null, 4);
+    writeFileSync(path, json);
 };
 
-class AddonExtension {
-    constructor(name, type) {
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.name = name;
-        this.type = type;
-    }
+class AddonExtension {
+    constructor(name, type) {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = name;
+        this.type = type;
+    }
 }
 
-const frontendExtensionType = 'ExperienceSpaceExtension';
-class FrontendExtension extends AddonExtension {
-    constructor({ name, files, main }) {
-        super(name, frontendExtensionType);
-        Object.defineProperty(this, "main", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "files", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.main = main;
-        this.files = files;
-    }
+const frontendExtensionType = 'ExperienceSpaceExtension';
+class FrontendExtension extends AddonExtension {
+    constructor({ name, files, main }) {
+        super(name, frontendExtensionType);
+        Object.defineProperty(this, "main", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "files", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.main = main;
+        this.files = files;
+    }
 }
 
-class UnknownExtension extends AddonExtension {
-    constructor(name, type, extensionData) {
-        super(name, type);
-        Object.defineProperty(this, "extensionData", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.extensionData = extensionData;
-    }
+class UnknownExtension extends AddonExtension {
+    constructor(name, type, extensionData) {
+        super(name, type);
+        Object.defineProperty(this, "extensionData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.extensionData = extensionData;
+    }
 }
 
-class AddonManifest {
-    constructor({ id, author, description, name, version, requireConfiguration }) {
-        Object.defineProperty(this, "id", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "author", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "description", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "version", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "manifestVersion", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "requireConfiguration", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "extensions", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "addFrontendExtension", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (name, fileUrls, mainFileUrl) => {
-                this.extensions.set(name, new FrontendExtension({
-                    name,
-                    main: mainFileUrl,
-                    files: fileUrls,
-                }));
-                return this;
-            }
-        });
-        Object.defineProperty(this, "addUnknownExtension", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (name, type, extensionData) => {
-                this.extensions.set(name, new UnknownExtension(name, type, extensionData));
-                return this;
-            }
-        });
-        Object.defineProperty(this, "getFrontendExtensions", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: () => {
-                const frontendExtensions = [];
-                this.extensions.forEach(extension => {
-                    if (extension instanceof FrontendExtension) {
-                        frontendExtensions.push(extension);
-                    }
-                });
-                return frontendExtensions;
-            }
-        });
-        Object.defineProperty(this, "writeFile", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (path) => {
-                const extensionsJson = [];
-                this.extensions.forEach(extension => {
-                    if (extension instanceof FrontendExtension) {
-                        extensionsJson.push({
-                            name: extension.name,
-                            type: extension.type,
-                            properties: {
-                                main: extension.main,
-                                files: extension.files,
-                            },
-                        });
-                    }
-                    else if (extension instanceof UnknownExtension) {
-                        extensionsJson.push(extension.extensionData);
-                    }
-                });
-                const manifestPath = resolve(path, 'manifest.json');
-                writeJsonFile(manifestPath, {
-                    id: this.id,
-                    name: this.name,
-                    author: this.author,
-                    description: this.description,
-                    manifestVersion: this.manifestVersion,
-                    requireConfiguration: this.requireConfiguration,
-                    version: this.version,
-                    extensions: extensionsJson,
-                });
-            }
-        });
-        this.id = id;
-        this.author = author || '';
-        this.description = description;
-        this.name = name;
-        this.manifestVersion = '1.0.0';
-        this.requireConfiguration = requireConfiguration || 'optional';
-        this.version = version;
-        this.extensions = new Map();
-    }
-}
-Object.defineProperty(AddonManifest, "fromFile", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: (manifestPath) => {
-        const manifestFile = readJsonFile(manifestPath);
-        const manifest = new AddonManifest({
-            id: manifestFile.id,
-            author: manifestFile.author,
-            description: manifestFile.description,
-            name: manifestFile.name,
-            version: manifestFile.version,
-            requireConfiguration: manifestFile.requireConfiguration,
-        });
-        for (const extension of manifestFile.extensions) {
-            if (extension.type === frontendExtensionType) {
-                const main = extension.properties.main;
-                const files = extension.properties.files;
-                manifest.addFrontendExtension(extension.name, files, main);
-            }
-            else {
-                manifest.addUnknownExtension(extension.name, extension.type, extension);
-            }
-        }
-        return manifest;
-    }
+class AddonManifest {
+    constructor({ id, author, description, name, version, requireConfiguration }) {
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "author", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "version", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "manifestVersion", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "requireConfiguration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "extensions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "addFrontendExtension", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (name, fileUrls, mainFileUrl) => {
+                this.extensions.set(name, new FrontendExtension({
+                    name,
+                    main: mainFileUrl,
+                    files: fileUrls,
+                }));
+                return this;
+            }
+        });
+        Object.defineProperty(this, "addUnknownExtension", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (name, type, extensionData) => {
+                this.extensions.set(name, new UnknownExtension(name, type, extensionData));
+                return this;
+            }
+        });
+        Object.defineProperty(this, "getFrontendExtensions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                const frontendExtensions = [];
+                this.extensions.forEach(extension => {
+                    if (extension instanceof FrontendExtension) {
+                        frontendExtensions.push(extension);
+                    }
+                });
+                return frontendExtensions;
+            }
+        });
+        Object.defineProperty(this, "writeFile", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (path) => {
+                const extensionsJson = [];
+                this.extensions.forEach(extension => {
+                    if (extension instanceof FrontendExtension) {
+                        extensionsJson.push({
+                            name: extension.name,
+                            type: extension.type,
+                            properties: {
+                                main: extension.main,
+                                files: extension.files,
+                            },
+                        });
+                    }
+                    else if (extension instanceof UnknownExtension) {
+                        extensionsJson.push(extension.extensionData);
+                    }
+                });
+                const manifestPath = resolve(path, 'manifest.json');
+                writeJsonFile(manifestPath, {
+                    id: this.id,
+                    name: this.name,
+                    author: this.author,
+                    description: this.description,
+                    manifestVersion: this.manifestVersion,
+                    requireConfiguration: this.requireConfiguration,
+                    version: this.version,
+                    extensions: extensionsJson,
+                });
+            }
+        });
+        this.id = id;
+        this.author = author || '';
+        this.description = description;
+        this.name = name;
+        this.manifestVersion = '1.0.0';
+        this.requireConfiguration = requireConfiguration || 'optional';
+        this.version = version;
+        this.extensions = new Map();
+    }
+}
+Object.defineProperty(AddonManifest, "fromFile", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: (manifestPath) => {
+        const manifestFile = readJsonFile(manifestPath);
+        const manifest = new AddonManifest({
+            id: manifestFile.id,
+            author: manifestFile.author,
+            description: manifestFile.description,
+            name: manifestFile.name,
+            version: manifestFile.version,
+            requireConfiguration: manifestFile.requireConfiguration,
+        });
+        for (const extension of manifestFile.extensions) {
+            if (extension.type === frontendExtensionType) {
+                const main = extension.properties.main;
+                const files = extension.properties.files;
+                manifest.addFrontendExtension(extension.name, files, main);
+            }
+            else {
+                manifest.addUnknownExtension(extension.name, extension.type, extension);
+            }
+        }
+        return manifest;
+    }
 });
 
 export { AddonManifest as A, readJsonFile as r, writeJsonFile as w };

package/dist/cli.js

@@ -6,274 +6,274 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync, createWriteStream }
 import { resolve, dirname, basename } from 'node:path';
 import Handlebars from 'handlebars';
 import { fileURLToPath } from 'node:url';
-import { r as readJsonFile, A as AddonManifest } from './addonManifest-30c25a45.js';
+import { r as readJsonFile, A as AddonManifest } from './addonManifest-45b9450a.js';
 import inquirer from 'inquirer';
 import isValidFilename from 'valid-filename';
 import archiver from 'archiver';
 
-const installDependencies = (cwd) => {
-    spawn.sync('npm', ['install'], {
-        stdio: 'inherit',
-        cwd,
-    });
+const installDependencies = (cwd) => {
+    spawn.sync('npm', ['install'], {
+        stdio: 'inherit',
+        cwd,
+    });
 };
 
-const runLinters = (cwd) => {
-    spawn.sync('npm', ['run', 'lint'], {
-        stdio: 'inherit',
-        cwd,
-    });
+const runLinters = (cwd) => {
+    spawn.sync('npm', ['run', 'lint'], {
+        stdio: 'inherit',
+        cwd,
+    });
 };
 
-const createFolder = (parentFolder, folderName) => {
-    const path = resolve(parentFolder, folderName);
-    if (!existsSync(path)) {
-        mkdirSync(path);
-    }
-    return path;
+const createFolder = (parentFolder, folderName) => {
+    const path = resolve(parentFolder, folderName);
+    if (!existsSync(path)) {
+        mkdirSync(path);
+    }
+    return path;
 };
 
-const createFileFromTemplate = (templateFilePath, destinationFilePath, templateParams) => {
-    const templateFile = readFileSync(templateFilePath, 'utf-8');
-    const template = Handlebars.compile(templateFile);
-    const file = template(templateParams);
-    mkdirSync(dirname(destinationFilePath), { recursive: true });
-    writeFileSync(destinationFilePath, file);
+const createFileFromTemplate = (templateFilePath, destinationFilePath, templateParams) => {
+    const templateFile = readFileSync(templateFilePath, 'utf-8');
+    const template = Handlebars.compile(templateFile);
+    const file = template(templateParams);
+    mkdirSync(dirname(destinationFilePath), { recursive: true });
+    writeFileSync(destinationFilePath, file);
 };
 
-/**
- * Return the path to currently executing binary (in node_modules)
- * @note This function is going to return an incorrect path if
- * a build does not bundle all files into a single javascript file!
- */
-const getBinaryPath = () => {
-    const filepath = fileURLToPath(import.meta.url);
-    const binaryPath = dirname(filepath);
-    return binaryPath;
+/**
+ * Return the path to currently executing binary (in node_modules)
+ * @note This function is going to return an incorrect path if
+ * a build does not bundle all files into a single javascript file!
+ */
+const getBinaryPath = () => {
+    const filepath = fileURLToPath(import.meta.url);
+    const binaryPath = dirname(filepath);
+    return binaryPath;
 };
 
-const getPackageJson = () => {
-    const binaryPath = getBinaryPath();
-    const packageJsonPath = resolve(binaryPath, '../package.json');
-    const packageJson = readJsonFile(packageJsonPath);
-    return packageJson;
+const getPackageJson = () => {
+    const binaryPath = getBinaryPath();
+    const packageJsonPath = resolve(binaryPath, '../package.json');
+    const packageJson = readJsonFile(packageJsonPath);
+    return packageJson;
 };
 
-const copyTemplate = ({ addonId, addonRootFolderPath, author, extensionDescription, extensionName, extensionRootFolderPath, sitesUrl, }) => {
-    const binaryPath = getBinaryPath();
-    const templatePath = resolve(binaryPath, 'addon/template');
-    const packageJson = getPackageJson();
-    createFileFromTemplate(resolve(templatePath, 'addonId.config.json.hbs'), resolve(addonRootFolderPath, `${addonId}.config.json`), {
-        extensionName,
-    });
-    [
-        '.browserslistrc',
-        '.editorconfig',
-        '.eslintrc.json',
-        '.gitignore',
-        '.prettierrc',
-        'babel.config.js',
-        'devServer.js',
-        'tsconfig.json',
-        'src/globals.ts',
-        'src/index.tsx',
-    ].forEach(fileName => {
-        createFileFromTemplate(resolve(templatePath, `extension/${fileName}.hbs`), resolve(extensionRootFolderPath, fileName));
-    });
-    createFileFromTemplate(resolve(templatePath, 'extension/package.json.hbs'), resolve(extensionRootFolderPath, 'package.json'), {
-        extensionName,
-        extensionDescription,
-        author,
-        addonId,
-        sitesUrl,
-        extensionsApiVersion: packageJson.dependencies['@tridion-sites/extensions'],
-        modelsVersion: packageJson.dependencies['@tridion-sites/models'],
-        openApiClientVersion: packageJson.dependencies['@tridion-sites/open-api-client'],
-        extensionsCliVersion: packageJson.version,
-    });
-    createFileFromTemplate(resolve(templatePath, 'extension/webpack.dev.config.js.hbs'), resolve(extensionRootFolderPath, 'webpack.dev.config.js'), {
-        extensionName,
-    });
-    createFileFromTemplate(resolve(templatePath, 'extension/webpack.prod.config.js.hbs'), resolve(extensionRootFolderPath, 'webpack.prod.config.js'), {
-        extensionName,
-    });
+const copyTemplate = ({ addonId, addonRootFolderPath, author, extensionDescription, extensionName, extensionRootFolderPath, sitesUrl, }) => {
+    const binaryPath = getBinaryPath();
+    const templatePath = resolve(binaryPath, 'addon/template');
+    const packageJson = getPackageJson();
+    createFileFromTemplate(resolve(templatePath, 'addonId.config.json.hbs'), resolve(addonRootFolderPath, `${addonId}.config.json`), {
+        extensionName,
+    });
+    [
+        '.browserslistrc',
+        '.editorconfig',
+        '.eslintrc.json',
+        '.gitignore',
+        '.prettierrc',
+        'babel.config.js',
+        'devServer.js',
+        'tsconfig.json',
+        'src/globals.ts',
+        'src/index.tsx',
+    ].forEach(fileName => {
+        createFileFromTemplate(resolve(templatePath, `extension/${fileName}.hbs`), resolve(extensionRootFolderPath, fileName));
+    });
+    createFileFromTemplate(resolve(templatePath, 'extension/package.json.hbs'), resolve(extensionRootFolderPath, 'package.json'), {
+        extensionName,
+        extensionDescription,
+        author,
+        addonId,
+        sitesUrl,
+        extensionsApiVersion: packageJson.dependencies['@tridion-sites/extensions'],
+        modelsVersion: packageJson.dependencies['@tridion-sites/models'],
+        openApiClientVersion: packageJson.dependencies['@tridion-sites/open-api-client'],
+        extensionsCliVersion: packageJson.version,
+    });
+    createFileFromTemplate(resolve(templatePath, 'extension/webpack.dev.config.js.hbs'), resolve(extensionRootFolderPath, 'webpack.dev.config.js'), {
+        extensionName,
+    });
+    createFileFromTemplate(resolve(templatePath, 'extension/webpack.prod.config.js.hbs'), resolve(extensionRootFolderPath, 'webpack.prod.config.js'), {
+        extensionName,
+    });
 };
 
-const createAddonPrompt = async () => {
-    return inquirer.prompt([
-        {
-            type: 'input',
-            name: 'addonId',
-            message: 'Provide id of the addon:',
-            default: 'my-addon',
-            validate: (input) => {
-                if (/\s+/g.test(input)) {
-                    return "Addon id can't have whitespace";
-                }
-                if (!isValidFilename(input)) {
-                    return "Addon id can't have reserved symbols";
-                }
-                return true;
-            },
-        },
-        {
-            type: 'input',
-            name: 'addonName',
-            message: 'Provide name of the addon:',
-            default: 'My addon',
-        },
-        {
-            type: 'input',
-            name: 'addonDescription',
-            message: 'Provide description of the addon:',
-            default: 'My addon for Tridion Experience Space',
-        },
-        {
-            type: 'input',
-            name: 'author',
-            message: `Provide author's name:`,
-            default: 'RWS',
-        },
-        {
-            type: 'input',
-            name: 'extensionName',
-            message: 'Provide the name of the frontend extension:',
-            default: 'my-extension',
-            validate: (input) => {
-                if (!/^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(input)) {
-                    return 'Extension name should adhere to package.json name requirements!';
-                }
-                return true;
-            },
-        },
-        {
-            type: 'input',
-            name: 'extensionDescription',
-            message: 'Provide description of the extension:',
-            default: 'My first extension',
-        },
-        {
-            type: 'input',
-            name: 'url',
-            message: `Provide the url to Tridion Sites:`,
-            validate: (input) => {
-                if (!/https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}(\.[a-zA-Z0-9()]{1,6})?\b([-a-zA-Z0-9()@:%_\+.~#?&\/=]*)/gm.test(input)) {
-                    return `Make sure it's a valid URL`;
-                }
-                return true;
-            },
-        },
-    ]);
+const createAddonPrompt = async () => {
+    return inquirer.prompt([
+        {
+            type: 'input',
+            name: 'addonId',
+            message: 'Provide id of the addon:',
+            default: 'my-addon',
+            validate: (input) => {
+                if (/\s+/g.test(input)) {
+                    return "Addon id can't have whitespace";
+                }
+                if (!isValidFilename(input)) {
+                    return "Addon id can't have reserved symbols";
+                }
+                return true;
+            },
+        },
+        {
+            type: 'input',
+            name: 'addonName',
+            message: 'Provide name of the addon:',
+            default: 'My addon',
+        },
+        {
+            type: 'input',
+            name: 'addonDescription',
+            message: 'Provide description of the addon:',
+            default: 'My addon for Tridion Experience Space',
+        },
+        {
+            type: 'input',
+            name: 'author',
+            message: `Provide author's name:`,
+            default: 'RWS',
+        },
+        {
+            type: 'input',
+            name: 'extensionName',
+            message: 'Provide the name of the frontend extension:',
+            default: 'my-extension',
+            validate: (input) => {
+                if (!/^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(input)) {
+                    return 'Extension name should adhere to package.json name requirements!';
+                }
+                return true;
+            },
+        },
+        {
+            type: 'input',
+            name: 'extensionDescription',
+            message: 'Provide description of the extension:',
+            default: 'My first extension',
+        },
+        {
+            type: 'input',
+            name: 'url',
+            message: `Provide the url to Tridion Sites:`,
+            validate: (input) => {
+                if (!/https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}(\.[a-zA-Z0-9()]{1,6})?\b([-a-zA-Z0-9()@:%_\+.~#?&\/=]*)/gm.test(input)) {
+                    return `Make sure it's a valid URL`;
+                }
+                return true;
+            },
+        },
+    ]);
 };
 
-const createAddonRootFolder = ({ path, addonDescription, addonId, addonName, author, extensionName, }) => {
-    const addonFolderPath = createFolder(path, addonId);
-    const manifest = new AddonManifest({
-        version: '1.0.0',
-        id: addonId,
-        name: addonName,
-        description: addonDescription,
-        author: author,
-    });
-    manifest.addFrontendExtension(extensionName, [`dist\\${extensionName}\\main.js`], `dist\\${extensionName}\\main.js`);
-    manifest.writeFile(addonFolderPath);
-    return addonFolderPath;
+const createAddonRootFolder = ({ path, addonDescription, addonId, addonName, author, extensionName, }) => {
+    const addonFolderPath = createFolder(path, addonId);
+    const manifest = new AddonManifest({
+        version: '1.0.0',
+        id: addonId,
+        name: addonName,
+        description: addonDescription,
+        author: author,
+    });
+    manifest.addFrontendExtension(extensionName, [`dist\\${extensionName}\\main.js`], `dist\\${extensionName}\\main.js`);
+    manifest.writeFile(addonFolderPath);
+    return addonFolderPath;
 };
 
-const createAddon = async (path) => {
-    const answers = await createAddonPrompt();
-    const addonRootFolderPath = createAddonRootFolder({
-        path,
-        addonId: answers.addonId,
-        addonName: answers.addonName,
-        addonDescription: answers.addonDescription,
-        author: answers.author,
-        extensionName: answers.extensionName,
-    });
-    const extensionRootFolderPath = createFolder(addonRootFolderPath, answers.extensionName);
-    copyTemplate({
-        addonRootFolderPath,
-        extensionRootFolderPath,
-        addonId: answers.addonId,
-        author: answers.author,
-        extensionDescription: answers.extensionDescription,
-        extensionName: answers.extensionName,
-        sitesUrl: answers.url,
-    });
-    return {
-        addonFolderPath: addonRootFolderPath,
-        extensionFolderPath: extensionRootFolderPath,
-    };
+const createAddon = async (path) => {
+    const answers = await createAddonPrompt();
+    const addonRootFolderPath = createAddonRootFolder({
+        path,
+        addonId: answers.addonId,
+        addonName: answers.addonName,
+        addonDescription: answers.addonDescription,
+        author: answers.author,
+        extensionName: answers.extensionName,
+    });
+    const extensionRootFolderPath = createFolder(addonRootFolderPath, answers.extensionName);
+    copyTemplate({
+        addonRootFolderPath,
+        extensionRootFolderPath,
+        addonId: answers.addonId,
+        author: answers.author,
+        extensionDescription: answers.extensionDescription,
+        extensionName: answers.extensionName,
+        sitesUrl: answers.url,
+    });
+    return {
+        addonFolderPath: addonRootFolderPath,
+        extensionFolderPath: extensionRootFolderPath,
+    };
 };
 
-const configureHandlebars = () => {
-    Handlebars.registerHelper('camelCase', (text) => {
-        return text.replace(/^./gm, match => match.toLowerCase());
-    });
-    Handlebars.registerHelper('kebabCase', (text) => {
-        return text.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
-    });
+const configureHandlebars = () => {
+    Handlebars.registerHelper('camelCase', (text) => {
+        return text.replace(/^./gm, match => match.toLowerCase());
+    });
+    Handlebars.registerHelper('kebabCase', (text) => {
+        return text.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
+    });
 };
 
-configureHandlebars();
-const createCommand = async () => {
-    const currentProcessPath = process.cwd();
-    console.info(chalk.green(`Creating a new addon at: ${currentProcessPath}`));
-    const { extensionFolderPath } = await createAddon(currentProcessPath);
-    console.info(chalk.green(`Installing dependencies`));
-    installDependencies(extensionFolderPath);
-    console.info(chalk.green(`Running linters`));
-    runLinters(extensionFolderPath);
-    console.info(chalk.green('🎉️️ All done! Happy hacking!'));
-    console.info(chalk.green(`Your extension is available at: ${extensionFolderPath}`));
+configureHandlebars();
+const createCommand = async () => {
+    const currentProcessPath = process.cwd();
+    console.info(chalk.green(`Creating a new addon at: ${currentProcessPath}`));
+    const { extensionFolderPath } = await createAddon(currentProcessPath);
+    console.info(chalk.green(`Installing dependencies`));
+    installDependencies(extensionFolderPath);
+    console.info(chalk.green(`Running linters`));
+    runLinters(extensionFolderPath);
+    console.info(chalk.green('🎉️️ All done! Happy hacking!'));
+    console.info(chalk.green(`Your extension is available at: ${extensionFolderPath}`));
 };
 
-const packCommand = ({ inputFilesPath, manifestPath, outputPath }) => {
-    console.info(chalk.green(`Creating an addon package from folder: ${inputFilesPath}`));
-    console.info(chalk.green(`Manifest file path: ${manifestPath}`));
-    const manifest = AddonManifest.fromFile(manifestPath);
-    const packageName = `${manifest.id}-${manifest.version}.zip`;
-    const archive = archiver('zip');
-    const zipPath = resolve(outputPath, packageName);
-    const stream = createWriteStream(zipPath);
-    stream.on('close', () => {
-        console.info(chalk.green(`Addon package "${packageName}" has been created at: ${zipPath}.`));
-        console.info(chalk.green('It can be uploaded into Addon Manager now.'));
-    });
-    archive.on('error', error => {
-        console.warn('We were unable to create a package.');
-        throw error;
-    });
-    archive.pipe(stream);
-    archive.file(manifestPath, { name: basename(manifestPath) });
-    archive.directory(inputFilesPath, basename(resolve(inputFilesPath)));
-    archive.finalize();
+const packCommand = ({ inputFilesPath, manifestPath, outputPath }) => {
+    console.info(chalk.green(`Creating an addon package from folder: ${inputFilesPath}`));
+    console.info(chalk.green(`Manifest file path: ${manifestPath}`));
+    const manifest = AddonManifest.fromFile(manifestPath);
+    const packageName = `${manifest.id}-${manifest.version}.zip`;
+    const archive = archiver('zip');
+    const zipPath = resolve(outputPath, packageName);
+    const stream = createWriteStream(zipPath);
+    stream.on('close', () => {
+        console.info(chalk.green(`Addon package "${packageName}" has been created at: ${zipPath}.`));
+        console.info(chalk.green('It can be uploaded into Addon Manager now.'));
+    });
+    archive.on('error', error => {
+        console.warn('We were unable to create a package.');
+        throw error;
+    });
+    archive.pipe(stream);
+    archive.file(manifestPath, { name: basename(manifestPath) });
+    archive.directory(inputFilesPath, basename(resolve(inputFilesPath)));
+    archive.finalize();
 };
 
-const packageJson = getPackageJson();
-const program = new Command();
-const programName = Object.keys(packageJson.bin)[0];
-program
-    .name(programName)
-    .description('Provides helpers to build, run and deploy addons for Tridion Experience Space')
-    .version(packageJson.version);
-program
-    .command('create')
-    .description('Create new Tridion Experience Space addon')
-    .usage(`${programName} create`)
-    .action(createCommand);
-program
-    .command('pack')
-    .description('Creates a package ready to be used in Addon Manager')
-    .usage(`${programName} pack`)
-    .requiredOption('-i, --input <string>', 'path to the directory with addon files')
-    .requiredOption('-m, --manifest <string>', 'path to the addon manifest file')
-    .requiredOption('-o, --output <string>', 'path where to output the package')
-    .action(args => {
-    packCommand({
-        inputFilesPath: args.input,
-        manifestPath: args.manifest,
-        outputPath: args.output,
-    });
-});
+const packageJson = getPackageJson();
+const program = new Command();
+const programName = Object.keys(packageJson.bin)[0];
+program
+    .name(programName)
+    .description('Provides helpers to build, run and deploy addons for Tridion Experience Space')
+    .version(packageJson.version);
+program
+    .command('create')
+    .description('Create new Tridion Experience Space addon')
+    .usage(`${programName} create`)
+    .action(createCommand);
+program
+    .command('pack')
+    .description('Creates a package ready to be used in Addon Manager')
+    .usage(`${programName} pack`)
+    .requiredOption('-i, --input <string>', 'path to the directory with addon files')
+    .requiredOption('-m, --manifest <string>', 'path to the addon manifest file')
+    .requiredOption('-o, --output <string>', 'path where to output the package')
+    .action(args => {
+    packCommand({
+        inputFilesPath: args.input,
+        manifestPath: args.manifest,
+        outputPath: args.output,
+    });
+});
 program.parse(process.argv);

package/dist/index.js

@@ -1,83 +1,83 @@
 #!/usr/bin/env node
 import { resolve, basename } from 'node:path';
-import { w as writeJsonFile, r as readJsonFile, A as AddonManifest } from './addonManifest-30c25a45.js';
+import { w as writeJsonFile, r as readJsonFile, A as AddonManifest } from './addonManifest-45b9450a.js';
 import 'node:fs';
 
-class AddonConfiguration {
-    constructor(fileName, configPerExtension) {
-        Object.defineProperty(this, "fileName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "configPerExtension", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "writeFile", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: (path) => {
-                const configPath = resolve(path, this.fileName);
-                writeJsonFile(configPath, {
-                    configuration: this.configPerExtension,
-                });
-            }
-        });
-        this.fileName = fileName;
-        this.configPerExtension = configPerExtension;
-    }
-}
-Object.defineProperty(AddonConfiguration, "fromFile", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: (configurationFilePath) => {
-        const configurationFile = readJsonFile(configurationFilePath);
-        const configuration = new AddonConfiguration(basename(configurationFilePath), configurationFile.configuration);
-        return configuration;
-    }
+class AddonConfiguration {
+    constructor(fileName, configPerExtension) {
+        Object.defineProperty(this, "fileName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "configPerExtension", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "writeFile", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (path) => {
+                const configPath = resolve(path, this.fileName);
+                writeJsonFile(configPath, {
+                    configuration: this.configPerExtension,
+                });
+            }
+        });
+        this.fileName = fileName;
+        this.configPerExtension = configPerExtension;
+    }
+}
+Object.defineProperty(AddonConfiguration, "fromFile", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: (configurationFilePath) => {
+        const configurationFile = readJsonFile(configurationFilePath);
+        const configuration = new AddonConfiguration(basename(configurationFilePath), configurationFile.configuration);
+        return configuration;
+    }
 });
 
-const extensionsRequestBasePath = '/api/uiExtensionsRepository';
-const getLocalFrontendAddon = ({ manifestPath, addonConfigPath }) => {
-    const manifest = AddonManifest.fromFile(manifestPath);
-    const addonConfiguration = addonConfigPath ? AddonConfiguration.fromFile(addonConfigPath) : undefined;
-    const localAddon = {
-        Hash: Date.now().toString(),
-        Id: 'LocalAddon',
-        Configuration: {},
-        Extensions: [],
-    };
-    const localExtensions = manifest.getFrontendExtensions();
-    localExtensions.forEach(extension => {
-        var _a;
-        localAddon.Configuration[extension.name] = (addonConfiguration === null || addonConfiguration === void 0 ? void 0 : addonConfiguration.configPerExtension[extension.name]) || {};
-        const extensionFiles = extension.files.map(filePath => `${extensionsRequestBasePath}/${extension.name}/${filePath}?hash=${Date.now()}`);
-        (_a = localAddon.Extensions) === null || _a === void 0 ? void 0 : _a.push({
-            Name: extension.name,
-            MainFile: `${extensionsRequestBasePath}/${extension.name}/${extension.main}`,
-            Contents: extensionFiles,
-        });
-    });
-    return localAddon;
+const extensionsRequestBasePath = '/api/uiExtensionsRepository';
+const getLocalFrontendAddon = ({ manifestPath, addonConfigPath }) => {
+    const manifest = AddonManifest.fromFile(manifestPath);
+    const addonConfiguration = addonConfigPath ? AddonConfiguration.fromFile(addonConfigPath) : undefined;
+    const localAddon = {
+        Hash: Date.now().toString(),
+        Id: 'LocalAddon',
+        Configuration: {},
+        Extensions: [],
+    };
+    const localExtensions = manifest.getFrontendExtensions();
+    localExtensions.forEach(extension => {
+        var _a;
+        localAddon.Configuration[extension.name] = (addonConfiguration === null || addonConfiguration === void 0 ? void 0 : addonConfiguration.configPerExtension[extension.name]) || {};
+        const extensionFiles = extension.files.map(filePath => `${extensionsRequestBasePath}/${extension.name}/${filePath}?hash=${Date.now()}`);
+        (_a = localAddon.Extensions) === null || _a === void 0 ? void 0 : _a.push({
+            Name: extension.name,
+            MainFile: `${extensionsRequestBasePath}/${extension.name}/${extension.main}`,
+            Contents: extensionFiles,
+        });
+    });
+    return localAddon;
 };
 
-const setupExtensionsResponse = ({ app, webAppPath, manifestPath, addonConfigPath, }) => {
-    const basePath = webAppPath.endsWith('/') ? webAppPath : `${webAppPath}/`;
-    app.get(`${basePath}api/v2.0/extensions`, (request, response) => {
-        const localAddon = getLocalFrontendAddon({
-            manifestPath,
-            addonConfigPath,
-        });
-        const liveAddons = /*await ExtensionsService.getExtensions()*/ [];
-        const result = [...liveAddons, localAddon];
-        response.json(result);
-    });
+const setupExtensionsResponse = ({ app, webAppPath, manifestPath, addonConfigPath, }) => {
+    const basePath = webAppPath.endsWith('/') ? webAppPath : `${webAppPath}/`;
+    app.get(`${basePath}api/v2.0/extensions`, (request, response) => {
+        const localAddon = getLocalFrontendAddon({
+            manifestPath,
+            addonConfigPath,
+        });
+        const liveAddons = /*await ExtensionsService.getExtensions()*/ [];
+        const result = [...liveAddons, localAddon];
+        response.json(result);
+    });
 };
 
 export { extensionsRequestBasePath, getLocalFrontendAddon, setupExtensionsResponse };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tridion-sites/extensions-cli",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "CLI to develop, build and package extensions for Tridion Experience Space",
   "author": "RWS",
   "homepage": "https://www.rws.com",
@@ -31,9 +31,9 @@
     "test": "sites-extensions"
   },
   "dependencies": {
-    "@tridion-sites/extensions": "0.5.0",
-    "@tridion-sites/models": "0.1.0",
-    "@tridion-sites/open-api-client": "1.0.4",
+    "@tridion-sites/extensions": "0.5.2",
+    "@tridion-sites/models": "0.1.2",
+    "@tridion-sites/open-api-client": "1.0.5",
     "archiver": "5.3.1",
     "chalk": "5.2.0",
     "commander": "10.0.0",
@@ -59,7 +59,7 @@
     "rollup": "3.11.0",
     "rollup-plugin-delete": "2.0.0",
     "rollup-plugin-node-externals": "5.1.0",
-    "typescript": "4.9.4",
+    "typescript": "5.0.4",
     "typescript-transform-paths": "3.4.6"
   }
 }

package/dist/addon/template/extension/.npmrc.hbs

@@ -1 +0,0 @@
-@tridion-sites:registry=https://nexus.sdl.com/repository/npm/