@tridion-sites/extensions-cli 0.3.2

package/dist/cli.js

@@ -0,0 +1,281 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import spawn from 'cross-spawn';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, createWriteStream } from 'node:fs';
+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 inquirer from 'inquirer';
+import isValidFilename from 'valid-filename';
+import archiver from 'archiver';
+
+const installDependencies = (cwd) => {
+    spawn.sync('npm', ['install'], {
+        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 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;
+};
+
+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.css',
+        'src/index.tsx',
+        'types/css.d.ts',
+    ].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 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.css`], `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 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}`));
+};
+
+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,
+    });
+});
+program.parse(process.argv);

package/dist/extensionPoints/primaryNavigation/template/PageComponent/PageComponent.module.css.hbs

@@ -0,0 +1,4 @@
+.{{kebabCase componentName}} {
+    padding: 60px;
+    background: #ccc;
+}

package/dist/extensionPoints/primaryNavigation/template/PageComponent/PageComponent.tsx.hbs

@@ -0,0 +1,9 @@
+import { useUserProfile } from '@tridion-sites/extensions';
+
+import styles from './{{componentName}}.module.css';
+
+export const {{componentName}} = () => {
+    const { userProfile } = useUserProfile();
+
+    return <div className={styles.{{camelCase componentName~}} }>Hi {userProfile.displayName}!</div>;
+};

package/dist/extensionPoints/primaryNavigation/template/PageComponent/index.ts.hbs

@@ -0,0 +1 @@
+export * from './{{componentName}}';

package/dist/extensionPoints/primaryNavigation/template/extensionPoint.hbs

@@ -0,0 +1,15 @@
+builder.header.navigation.register(() => ({
+    id: '{{id}}',
+    routePath: '{{routePath}}',
+    routeComponent: {{routeComponentName}},
+    useNavigationItem: () => {
+        return {
+            isAvailable: true,
+            isInitialized: true,
+            label: '{{label}}',
+        }
+    }
+
+}));
+
+builder.header.navigation.config.add('{{id}}');

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+import type { FrontendAddon } from '@tridion-sites/open-api-client';
+
+export declare const extensionsRequestBasePath = "/api/uiExtensionsRepository";
+
+export declare const getLocalFrontendAddon: ({ manifestPath, addonConfigPath }: GetLocalFrontendAddonParams) => FrontendAddon;
+
+export declare interface GetLocalFrontendAddonParams {
+    manifestPath: string;
+    addonConfigPath?: string;
+}
+
+declare interface Request_2 extends Record<string, any> {
+}
+
+declare type RequestListener = (request: Request_2, response: Response_2) => void;
+
+declare interface Response_2 extends Record<string, any> {
+    json: (result: any) => void;
+}
+
+export declare const setupExtensionsResponse: ({ app, webAppPath, manifestPath, addonConfigPath, }: SetupExtensionsResponseParams) => void;
+
+declare interface SetupExtensionsResponseApp extends Record<string, any> {
+    get: (path: string, listener: RequestListener) => void;
+}
+
+export declare interface SetupExtensionsResponseParams {
+    app: SetupExtensionsResponseApp;
+    webAppPath: string;
+    manifestPath: string;
+    addonConfigPath?: string;
+}
+
+export { }

package/dist/index.js

@@ -0,0 +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 '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;
+    }
+});
+
+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);
+    });
+};
+
+export { extensionsRequestBasePath, getLocalFrontendAddon, setupExtensionsResponse };

package/dist/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.20.1"
+    }
+  ]
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@tridion-sites/extensions-cli",
+  "version": "0.3.2",
+  "description": "CLI to develop, build and package extensions for Tridion Experience Space",
+  "author": "RWS",
+  "homepage": "https://www.rws.com",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "typings": "./dist/index.d.ts",
+  "bin": {
+    "sites-extensions": "./dist/cli.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://stash.sdl.com/scm/tdx/tridion-sites.git"
+  },
+  "bugs": {
+    "url": "https://jira.sdl.com/projects/DXUI/issues/"
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "rollup -c && yarn run docs:extract --local && rimraf dist/dts",
+    "build:ci": "rollup -c && yarn run docs:extract && rimraf dist/dts",
+    "lint": "eslint . --fix && prettier --write \"src/**/*\"",
+    "prepublish": "yarn build",
+    "test": "sites-extensions"
+  },
+  "dependencies": {
+    "@tridion-sites/extensions": "0.5.0",
+    "@tridion-sites/models": "0.1.0",
+    "@tridion-sites/open-api-client": "1.0.4",
+    "archiver": "5.3.1",
+    "chalk": "5.2.0",
+    "commander": "10.0.0",
+    "cross-spawn": "7.0.3",
+    "decamelize": "6.0.0",
+    "fs-extra": "11.1.0",
+    "handlebars": "4.7.7",
+    "inquirer": "9.1.4",
+    "valid-filename": "4.0.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "24.0.1",
+    "@rollup/plugin-node-resolve": "15.0.1",
+    "@rollup/plugin-typescript": "11.0.0",
+    "@types/archiver": "5.3.1",
+    "@types/compression": "1.7.2",
+    "@types/cross-spawn": "6.0.2",
+    "@types/fs-extra": "11.0.1",
+    "@types/inquirer": "9.0.3",
+    "@types/node": "18.11.18",
+    "@web/rollup-plugin-copy": "0.3.0",
+    "rimraf": "4.1.2",
+    "rollup": "3.11.0",
+    "rollup-plugin-delete": "2.0.0",
+    "rollup-plugin-node-externals": "5.1.0",
+    "typescript": "4.9.4",
+    "typescript-transform-paths": "3.4.6"
+  }
+}