@unisphere/nx 4.10.1 → 4.11.0

package/dist/generators/add-runtime/add-runtime.d.ts

@@ -1,5 +1,5 @@
 import { Tree } from '@nx/devkit';
 import { AddRuntimeGeneratorSchema } from './schema';
-export declare function addRuntimeGenerator(tree: Tree, options: AddRuntimeGeneratorSchema): Promise<() => void>;
+export declare function addRuntimeGenerator(tree: Tree, options: AddRuntimeGeneratorSchema): Promise<any>;
 export default addRuntimeGenerator;
 //# sourceMappingURL=add-runtime.d.ts.map

package/dist/generators/add-runtime/add-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"add-runtime.d.ts","sourceRoot":"","sources":["../../../src/generators/add-runtime/add-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,IAAI,EAAsC,MAAM,YAAY,CAAC;AAElG,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AAgErD,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,yBAAyB,uBA4GnC;AAED,eAAe,mBAAmB,CAAC"}
+{"version":3,"file":"add-runtime.d.ts","sourceRoot":"","sources":["../../../src/generators/add-runtime/add-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,IAAI,EAAsC,MAAM,YAAY,CAAC;AAUlG,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AA0SrD,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,yBAAyB,gBAgHnC;AAED,eAAe,mBAAmB,CAAC"}

package/dist/generators/add-runtime/add-runtime.js

@@ -4,8 +4,10 @@ exports.addRuntimeGenerator = addRuntimeGenerator;
 const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
 const path = tslib_1.__importStar(require("path"));
+const ts_morph_1 = require("ts-morph");
 const utils_1 = require("../utils");
 const dependency_config_1 = require("../dependency-config");
+const visual_utils_1 = require("../add-visual/visual-utils");
 function validateOptions(options) {
     if (!options.name || options.name.trim() === '') {
         throw new Error(`Missing required option: 'name'\n` +
@@ -21,6 +23,150 @@ function validateOptions(options) {
             `  Received: ${options.name}`);
     }
 }
+function validateFlavorName(flavor) {
+    if (!flavor || flavor.trim() === '') {
+        throw new Error(`Missing required option: 'flavor'\n` +
+            `  Description: The name of the flavor to add\n` +
+            `  Pattern: ^[a-zA-Z][a-zA-Z0-9\\-\\s]*$`);
+    }
+    const namePattern = /^[a-zA-Z][a-zA-Z0-9\-\s]*$/;
+    if (!namePattern.test(flavor)) {
+        throw new Error(`Invalid value '${flavor}' for option 'flavor'\n` +
+            `  Pattern: ^[a-zA-Z][a-zA-Z0-9\\-\\s]*$\n` +
+            `  Received: ${flavor}`);
+    }
+    if ((0, devkit_1.names)(flavor).fileName === 'default') {
+        throw new Error(`Flavor name 'default' is reserved. The default flavor is runtime.tsx.\n` +
+            `  Please choose a different flavor name.`);
+    }
+}
+function updateCreateFactory(tree, sourceRoot, flavorNames, project) {
+    const factoryPath = [`${sourceRoot}/src/lib/create-factory.tsx`, `${sourceRoot}/src/lib/create-factory.ts`]
+        .find((p) => tree.exists(p));
+    if (!factoryPath) {
+        throw new Error(`Create factory file not found in ${sourceRoot}/src/lib/.\n` +
+            `  Expected: create-factory.tsx or create-factory.ts`);
+    }
+    const sourceFile = (0, visual_utils_1.loadSourceFile)(tree, factoryPath, project);
+    const flavorLowerDash = flavorNames['flavorName__lowerDashCase'];
+    const flavorPascal = flavorNames['flavorName__pascalCase'];
+    const className = `Runtime${flavorPascal}`;
+    const alreadyImported = sourceFile
+        .getImportDeclarations()
+        .some((decl) => decl.getNamedImports().some((imp) => imp.getName() === className));
+    if (alreadyImported) {
+        console.log(`⚠️ Import for ${className} already exists in create-factory.`);
+        return;
+    }
+    sourceFile.addImportDeclaration({
+        kind: ts_morph_1.StructureKind.ImportDeclaration,
+        namedImports: [className],
+        moduleSpecifier: `./runtime-${flavorLowerDash}`,
+    });
+    const switchStatement = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.SwitchStatement)[0];
+    if (!switchStatement) {
+        const createMethod = sourceFile
+            .getDescendantsOfKind(ts_morph_1.SyntaxKind.MethodDeclaration)
+            .find((m) => m.getName() === 'create');
+        (0, visual_utils_1.throwIfNotFound)(createMethod, `No 'create' method found in ${factoryPath}`);
+        const returnStatement = createMethod.getDescendantsOfKind(ts_morph_1.SyntaxKind.ReturnStatement)[0];
+        (0, visual_utils_1.throwIfNotFound)(returnStatement, `No return statement found in create method in ${factoryPath}`);
+        const returnExpr = returnStatement.getExpression()?.getText() || 'new Runtime(options)';
+        returnStatement.replaceWithText(`switch (options.flavor) {\n` +
+            `      case '${flavorLowerDash}':\n` +
+            `        return new ${className}(options) as any;\n` +
+            `      default:\n` +
+            `        return ${returnExpr};\n` +
+            `    }`);
+    }
+    else {
+        const caseBlock = switchStatement.getCaseBlock();
+        const cases = caseBlock.getClauses();
+        const caseExists = cases.some((c) => {
+            if (c.getKind() === ts_morph_1.SyntaxKind.CaseClause) {
+                const clause = c;
+                return clause.getExpression()?.getText().replace(/['"]/g, '') === flavorLowerDash;
+            }
+            return false;
+        });
+        if (caseExists) {
+            console.log(`⚠️ Switch case for flavor '${flavorLowerDash}' already exists.`);
+            return;
+        }
+        const newCase = `case '${flavorLowerDash}':\n        return new ${className}(options) as any;`;
+        const defaultIndex = cases.findIndex((c) => c.getKind() === ts_morph_1.SyntaxKind.DefaultClause);
+        if (defaultIndex !== -1) {
+            const defaultClause = cases[defaultIndex];
+            defaultClause.replaceWithText(`${newCase}\n      ${defaultClause.getText()}`);
+        }
+        else {
+            const lastCase = cases[cases.length - 1];
+            lastCase.replaceWithText(`${lastCase.getText()}\n      ${newCase}`);
+        }
+    }
+    (0, visual_utils_1.saveSourceFile)(tree, factoryPath, sourceFile.getFullText());
+    console.log(`✅ Updated create-factory with flavor '${flavorLowerDash}'`);
+}
+function updateFlavorTypesIndexExport(tree, runtimeName, flavorLowerDash, typesPackageInfo) {
+    const indexPath = `${typesPackageInfo.basePath}/src/lib/${runtimeName}-runtime/index.ts`;
+    if (!tree.exists(indexPath)) {
+        throw new Error(`Runtime types index not found at ${indexPath}`);
+    }
+    const currentContent = tree.read(indexPath, 'utf-8');
+    if (!currentContent) {
+        throw new Error(`Failed to read content from ${indexPath}`);
+    }
+    const exportLine = `export * from './runtime-${flavorLowerDash}-types';`;
+    if (currentContent.includes(exportLine)) {
+        return;
+    }
+    const updatedContent = currentContent.replace(/\n\n$/, '\n') + exportLine;
+    tree.write(indexPath, updatedContent);
+}
+async function addFlavorToRuntime(tree, options) {
+    const runtimeName = (0, devkit_1.names)(options.name).fileName;
+    const flavor = options.flavor;
+    validateFlavorName(flavor);
+    const unisphereConfig = (0, utils_1.validateUnisphereConfig)(tree);
+    const sourceRoot = (0, utils_1.validateRuntimeExists)(tree, runtimeName);
+    const typesPackageInfo = (0, utils_1.findTypesOrCorePackageInfo)(tree);
+    const flavorLowerDash = (0, devkit_1.names)(flavor).fileName;
+    const flavorFilePath = `${sourceRoot}/src/lib/runtime-${flavorLowerDash}.tsx`;
+    if (tree.exists(flavorFilePath)) {
+        throw new Error(`Flavor file already exists at ${flavorFilePath}.\n` +
+            `  Choose a different flavor name or remove the existing file.`);
+    }
+    const flavorTypesPath = `${typesPackageInfo.basePath}/src/lib/${runtimeName}-runtime/runtime-${flavorLowerDash}-types.ts`;
+    if (tree.exists(flavorTypesPath)) {
+        throw new Error(`Flavor types file already exists at ${flavorTypesPath}.\n` +
+            `  Choose a different flavor name or remove the existing file.`);
+    }
+    const runtimeNames = (0, utils_1.createNameTransforms)(runtimeName, 'runtimeName');
+    const flavorNames = (0, utils_1.createNameTransforms)(flavorLowerDash, 'flavorName');
+    const widgetNames = (0, utils_1.createNameTransforms)(unisphereConfig.name, 'widgetName');
+    const templateVariables = {
+        ...runtimeNames,
+        ...flavorNames,
+        ...widgetNames,
+        typesAlias: typesPackageInfo.alias,
+        tmpl: '',
+    };
+    (0, devkit_1.generateFiles)(tree, path.join(__dirname, 'templates/new-flavor'), `${sourceRoot}/src/lib`, templateVariables);
+    (0, devkit_1.generateFiles)(tree, path.join(__dirname, 'templates/new-flavor-types'), `${typesPackageInfo.basePath}/src/lib/${runtimeName}-runtime`, templateVariables);
+    updateFlavorTypesIndexExport(tree, runtimeName, flavorLowerDash, typesPackageInfo);
+    const project = new ts_morph_1.Project({
+        useInMemoryFileSystem: true,
+        skipAddingFilesFromTsConfig: true,
+    });
+    updateCreateFactory(tree, sourceRoot, flavorNames, project);
+    await (0, devkit_1.formatFiles)(tree);
+    console.log(`\n🎉 Successfully added flavor '${flavorLowerDash}' to runtime '${runtimeName}'!`);
+    console.log(`   Flavor file: ${flavorFilePath}`);
+    console.log(`   Types file: ${flavorTypesPath}`);
+    return () => {
+        return { runtimeName, flavor: flavorLowerDash };
+    };
+}
 function updateTypesIndexExport(tree, runtimeName, basePath) {
     const indexPath = `${basePath}/src/index.ts`;
     if (!tree.exists(indexPath)) {
@@ -41,6 +187,9 @@ function updateTypesIndexExport(tree, runtimeName, basePath) {
 }
 async function addRuntimeGenerator(tree, options) {
     validateOptions(options);
+    if (options.flavor) {
+        return addFlavorToRuntime(tree, options);
+    }
     // Validate and read .unisphere configuration
     const unisphereConfig = (0, utils_1.validateUnisphereConfig)(tree);
     // Validate dependencies

package/dist/generators/add-runtime/schema.d.ts

@@ -2,4 +2,5 @@ export interface AddRuntimeGeneratorSchema {
   name: string;
   dependencies?: string[];
   analyticsAppId?: number;
+  flavor?: string;
 }

package/dist/generators/add-runtime/schema.json

@@ -21,6 +21,11 @@
     "analyticsAppId": {
       "type": "number",
       "description": "Analytics app ID (optional, can be set later in runtime constructor)"
+    },
+    "flavor": {
+      "type": "string",
+      "description": "Name of the flavor to add to an existing runtime (e.g. 'player-plugin')",
+      "pattern": "^[a-zA-Z][a-zA-Z0-9\\-\\s]*$"
     }
   },
   "required": [

package/dist/generators/add-runtime/templates/new-flavor/runtime-__flavorName__.tsx.template

@@ -0,0 +1,63 @@
+import * as ReactDOM from 'react-dom/client';
+import { Root } from 'react-dom/client';
+import {
+  CreateElementOptions,
+  UnisphereRuntimeBase,
+} from '@unisphere/runtime-js';
+import {
+  <%= runtimeName__pascalCase %>Runtime<%= flavorName__pascalCase %>Settings,
+  <%= runtimeName__camelCase %>Runtime<%= flavorName__pascalCase %>SettingsSchema,
+  <%= runtimeName__pascalCase %>RuntimeName,
+  <%= runtimeName__pascalCase %><%= flavorName__pascalCase %>Runtime,
+  widgetName,
+} from '<%= typesAlias %>';
+import { HtmlDomRuntimeVisual } from '@unisphere/runtime';
+
+export class Runtime<%= flavorName__pascalCase %>
+  extends UnisphereRuntimeBase<<%= runtimeName__pascalCase %>Runtime<%= flavorName__pascalCase %>Settings, Root>
+  implements <%= runtimeName__pascalCase %><%= flavorName__pascalCase %>Runtime {
+  readonly id = widgetName;
+  readonly runtime = <%= runtimeName__pascalCase %>RuntimeName;
+  readonly widgetName = widgetName;
+  readonly runtimeName = <%= runtimeName__pascalCase %>RuntimeName;
+  readonly flavor = '<%= flavorName__lowerDashCase %>';
+
+  protected _onKilled(): void {
+    this._logger.log('runtime killed');
+  }
+
+  constructor(options: CreateElementOptions<<%= runtimeName__pascalCase %>Runtime<%= flavorName__pascalCase %>Settings>) {
+    super({
+      ...options,
+      settingsSchema: <%= runtimeName__camelCase %>Runtime<%= flavorName__pascalCase %>SettingsSchema,
+      visualTypes: {},
+    });
+
+    this._logger.log('runtime initialized', {
+      data: {
+        widgetName: this.widgetName,
+        runtimeName: this.runtimeName,
+        flavor: this.flavor,
+      },
+    });
+  }
+
+  override _createVisualContainer(htmlElement: HTMLElement): Root {
+    return ReactDOM.createRoot(htmlElement);
+  }
+
+  override _onVisualMount(visual: HtmlDomRuntimeVisual<Root>) {
+    switch (visual.type) {
+      default:
+        return false;
+    }
+  }
+
+  override _onVisualUnmount(visual: HtmlDomRuntimeVisual<Root>) {
+    visual.htmlContainer?.unmount();
+  }
+
+  protected _onSettingsUpdated(settings: <%= runtimeName__pascalCase %>Runtime<%= flavorName__pascalCase %>Settings) {
+    // use this method to react to settings changes
+  }
+}

package/dist/generators/add-runtime/templates/new-flavor-types/runtime-__flavorName__-types.ts.template

@@ -0,0 +1,20 @@
+import { ValidatorSchema } from '@unisphere/core';
+import { UnisphereRuntimeBaseType } from '@unisphere/runtime';
+import { widgetName } from '../widget-types';
+import { <%= runtimeName__pascalCase %>RuntimeName } from './runtime-types';
+
+export interface <%= runtimeName__pascalCase %>Runtime<%= flavorName__pascalCase %>Settings {
+  schemaVersion?: string;
+}
+
+export const <%= runtimeName__camelCase %>Runtime<%= flavorName__pascalCase %>SettingsSchema: ValidatorSchema = {
+  type: 'object',
+  properties: {
+    schemaVersion: { type: 'literal', value: '1', optional: true },
+  },
+};
+
+export type <%= runtimeName__pascalCase %><%= flavorName__pascalCase %>Runtime = UnisphereRuntimeBaseType<<%= runtimeName__pascalCase %>Runtime<%= flavorName__pascalCase %>Settings> & {
+  readonly widgetName: typeof widgetName;
+  readonly runtimeName: typeof <%= runtimeName__pascalCase %>RuntimeName;
+}

package/dist/generators/add-runtime/templates/new-runtime/src/lib/runtime.tsx.template

@@ -9,9 +9,9 @@ import {
   <%= runtimeName__pascalCase %>RuntimeName,
   <%= runtimeName__pascalCase %>RuntimeSettings,
   <%= runtimeName__camelCase %>RuntimeSettingsSchema,
+  widgetName,
 } from '<%= typesAlias %>';
 import { HtmlDomRuntimeVisual, KalturaAnalyticsServiceType } from '@unisphere/runtime';
-import { widgetName } from '<%= typesAlias %>'
 
 export class Runtime
   extends UnisphereRuntimeBase<<%= runtimeName__pascalCase %>RuntimeSettings, Root>

package/dist/generators/add-visual/add-visual.d.ts

@@ -1,5 +1,7 @@
 import { Tree } from '@nx/devkit';
 import { AddVisualGeneratorSchema } from './schema';
+export declare function discoverAvailableFlavors(tree: Tree, sourceRoot: string): string[];
+export declare function resolveTargetFile(tree: Tree, sourceRoot: string, flavor: string | undefined): string;
 /**
  * Nx generator to create a new visual within a specified runtime.
  */

package/dist/generators/add-visual/add-visual.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"add-visual.d.ts","sourceRoot":"","sources":["../../../src/generators/add-visual/add-visual.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,IAAI,EAAE,MAAM,YAAY,CAAC;AAsB9D,OAAO,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAmapD;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,GAAG,CAAC,CA2Fd;AAED,eAAe,kBAAkB,CAAC"}
+{"version":3,"file":"add-visual.d.ts","sourceRoot":"","sources":["../../../src/generators/add-visual/add-visual.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,IAAI,EAAE,MAAM,YAAY,CAAC;AAsB9D,OAAO,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAapD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAUjF;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,IAAI,EACV,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,MAAM,CAuBR;AAwZD;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,GAAG,CAAC,CA6Ed;AAED,eAAe,kBAAkB,CAAC"}

package/dist/generators/add-visual/add-visual.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverAvailableFlavors = discoverAvailableFlavors;
+exports.resolveTargetFile = resolveTargetFile;
 exports.addVisualGenerator = addVisualGenerator;
 const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
@@ -7,6 +9,37 @@ const path = tslib_1.__importStar(require("path"));
 const ts_morph_1 = require("ts-morph");
 const utils_1 = require("../utils");
 const visual_utils_1 = require("./visual-utils");
+function discoverAvailableFlavors(tree, sourceRoot) {
+    const libDir = `${sourceRoot}/src/lib`;
+    if (!tree.exists(libDir)) {
+        return [];
+    }
+    return tree
+        .children(libDir)
+        .filter((f) => /^(runtime-.+|.+-runtime-base)\.tsx$/.test(f))
+        .map((f) => f.replace('.tsx', ''))
+        .sort();
+}
+function resolveTargetFile(tree, sourceRoot, flavor) {
+    const libDir = `${sourceRoot}/src/lib`;
+    if (!flavor) {
+        const defaultPath = `${libDir}/runtime.tsx`;
+        if (!tree.exists(defaultPath)) {
+            throw new Error(`Default runtime file not found at ${defaultPath}`);
+        }
+        return defaultPath;
+    }
+    const targetPath = `${libDir}/${flavor}.tsx`;
+    if (!tree.exists(targetPath)) {
+        const available = discoverAvailableFlavors(tree, sourceRoot);
+        throw new Error(`Flavor file '${flavor}.tsx' not found in ${libDir}.\n` +
+            (available.length > 0
+                ? `  Available flavors: ${available.join(', ')}\n`
+                : '') +
+            `  Omit --flavor to target the default runtime.`);
+    }
+    return targetPath;
+}
 function validateOptions(options) {
     if (!options.runtimeName || options.runtimeName.trim() === '') {
         throw new Error(`Missing required option: 'runtimeName'\n` +
@@ -130,8 +163,7 @@ function addVisualTypesToConstructor(sourceFilePath, tree, vars, project, isSing
     const visualTypesProp = (0, visual_utils_1.throwIfNotFound)(objectLiteral
         .getProperties()
         .find((prop) => prop.getKind() === ts_morph_1.SyntaxKind.PropertyAssignment &&
-        prop.getName() === 'visualTypes'), // Assert type after finding
-    `Could not find visualTypes property in super() call in ${sourceFilePath}`);
+        ['visualTypes', 'flavorVisualTypes'].includes(prop.getName())), `Could not find visualTypes or flavorVisualTypes property in super() call in ${sourceFilePath}`);
     const visualTypesObject = (0, visual_utils_1.throwIfNotFound)(visualTypesProp.getInitializer(), // Assert type after getting initializer
     `visualTypes is not an object literal in ${sourceFilePath}`);
     if ((0, visual_utils_1.propertyExists)(visualTypesObject, visualCamel)) {
@@ -287,18 +319,14 @@ async function addVisualGenerator(tree, options) {
     const isSingleOccurrence = options.isSingleOccurrence ?? false;
     // Extract environment variables
     const widgetName = unisphereConfig.name;
-    // Validate runtime existence and get source root path.
     const runtimeSourceRoot = (0, utils_1.validateRuntimeExists)(tree, runtimeName);
-    const runtimeTSxPath = `${runtimeSourceRoot}/src/lib/runtime.tsx`;
-    // Find types package (or fallback to core)
+    const targetFile = resolveTargetFile(tree, runtimeSourceRoot, options.flavor);
     const typesPackageInfo = (0, utils_1.findTypesOrCorePackageInfo)(tree);
     const runtimeNames = (0, utils_1.createNameTransforms)(runtimeName, 'runtimeName');
     const visualNames = (0, utils_1.createNameTransforms)(visualName, 'visualName');
     const widgetNames = (0, utils_1.createNameTransforms)(widgetName, 'widgetName');
-    // Derive specific names for runtime visual settings and schema based on transforms.
     const runtimeVisualSettings = `${runtimeNames.runtimeName__pascalCase}Runtime${visualNames.visualName__pascalCase}VisualSettings`;
     const runtimeVisualSchema = `${runtimeNames.runtimeName__camelCase}Runtime${visualNames.visualName__pascalCase}VisualSettingsSchema`;
-    // Combine all template variables for easy access and passing to functions.
     const templateVariables = {
         ...runtimeNames,
         ...visualNames,
@@ -307,30 +335,25 @@ async function addVisualGenerator(tree, options) {
         runtimeVisualSchema,
         typesAlias: typesPackageInfo.alias,
     };
-    // Ensure the target runtime file exists before proceeding.
-    if (!tree.exists(runtimeTSxPath)) {
-        throw new Error(`Runtime file not found at ${runtimeTSxPath}`);
-    }
-    // Initialize ts-morph project with an in-memory file system for modifications.
     const project = new ts_morph_1.Project({
         useInMemoryFileSystem: true,
         skipAddingFilesFromTsConfig: true,
     });
-    // Execute all code modification steps.
-    addImportToRuntime(runtimeTSxPath, tree, templateVariables, project);
-    addVisualTypesToConstructor(runtimeTSxPath, tree, templateVariables, project, isSingleOccurrence);
-    addSwitchCaseToRuntime(runtimeTSxPath, tree, templateVariables, project);
-    addRenderMethod(runtimeTSxPath, tree, templateVariables, project, typesPackageInfo);
-    // 'project' parameter is not needed here as createVisualTypes directly writes to the tree.
+    if (options.flavor) {
+        console.log(`\nProcessing flavor '${options.flavor}'...`);
+    }
+    addImportToRuntime(targetFile, tree, templateVariables, project);
+    addVisualTypesToConstructor(targetFile, tree, templateVariables, project, isSingleOccurrence);
+    addSwitchCaseToRuntime(targetFile, tree, templateVariables, project);
+    addRenderMethod(targetFile, tree, templateVariables, project, typesPackageInfo);
     createVisualTypes(tree, templateVariables, typesPackageInfo);
-    // Format all modified files for consistent code style.
     await (0, devkit_1.formatFiles)(tree);
-    // Log success and summary information to the console.
-    console.log(`\n🎉 Successfully added visual '${visualName}' to runtime '${runtimeName}'!`);
+    const flavorSummary = options.flavor ? ` (flavor: ${options.flavor})` : '';
+    console.log(`\n🎉 Successfully added visual '${visualName}' to runtime '${runtimeName}'${flavorSummary}!`);
     console.log(`   Runtime: ${runtimeName} (${runtimeSourceRoot})`);
+    console.log(`   Target: ${targetFile}`);
     console.log(`   Visual: ${visualName}`);
     console.log(`   Single occurrence: ${isSingleOccurrence ? 'Yes' : 'No'}`);
-    console.log(`   Modified file: ${runtimeTSxPath}`);
     return () => {
         return { visualName };
     };

package/dist/generators/add-visual/schema.d.ts

@@ -2,4 +2,5 @@ export interface AddVisualGeneratorSchema {
   runtimeName?: string;
   visualName?: string;
   isSingleOccurrence?: boolean;
+  flavor?: string;
 }

package/dist/generators/add-visual/schema.json

@@ -18,6 +18,10 @@
       "type": "boolean",
       "description": "Whether this visual is limited to single occurrence",
       "default": false
+    },
+    "flavor": {
+      "type": "string",
+      "description": "Target file name without .tsx extension (e.g. 'runtime-player-plugin', 'chat-runtime-base'). Omit to target the default runtime.tsx."
     }
   },
   "required": ["runtimeName", "visualName"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unisphere/nx",
-  "version": "4.10.1",
+  "version": "4.11.0",
   "private": false,
   "main": "./dist/index.js",
   "module": "./dist/index.js",