@unisphere/nx 1.0.1

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

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addVisualGenerator = addVisualGenerator;
+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 visual_utils_1 = require("./visual-utils");
+/**
+ * Adds necessary imports (runtimeVisualSettings, runtimeVisualSchema) to the runtime file.
+ */
+function addImportToRuntime(sourceFilePath, tree, vars, project) {
+    const sourceFile = (0, visual_utils_1.loadSourceFile)(tree, sourceFilePath, project);
+    const { visualName__humanReadable: humanName, runtimeVisualSettings, runtimeVisualSchema, coreAlias, } = vars;
+    // Check if import already exists to prevent duplicates
+    const alreadyExists = sourceFile
+        .getImportDeclarations()
+        .some((decl) => decl
+        .getNamedImports()
+        .some((imp) => imp.getName() === runtimeVisualSettings));
+    if (alreadyExists) {
+        console.log(`⚠️ Import for visual ${humanName} already exists.`);
+        return;
+    }
+    sourceFile.addImportDeclaration({
+        kind: ts_morph_1.StructureKind.ImportDeclaration,
+        namedImports: [runtimeVisualSettings, runtimeVisualSchema],
+        moduleSpecifier: coreAlias,
+    }); // Explicit cast for clarity
+    (0, visual_utils_1.saveSourceFile)(tree, sourceFilePath, sourceFile.getFullText());
+    console.log(`✅ Added import for visual ${humanName}`);
+}
+/**
+ * Adds a new case to the primary switch statement in the runtime file.
+ */
+function addSwitchCaseToRuntime(sourceFilePath, tree, vars, project) {
+    const sourceFile = (0, visual_utils_1.loadSourceFile)(tree, sourceFilePath, project);
+    const { visualName__camelCase: visualCamel, visualName__pascalCase: visualPascal, visualName__humanReadable: humanName, } = vars;
+    const switchStatement = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.SwitchStatement)[0];
+    (0, visual_utils_1.throwIfNotFound)(switchStatement, `No switch statement found in ${sourceFilePath}`);
+    const caseBlock = switchStatement.getCaseBlock();
+    const cases = caseBlock.getClauses();
+    const exists = cases.some((c) => {
+        if (c.getKind() === ts_morph_1.SyntaxKind.CaseClause) {
+            const clause = c;
+            return (clause.getExpression()?.getText().replace(/['"]/g, '') === visualCamel);
+        }
+        return false;
+    });
+    if (exists) {
+        console.log(`⚠️ Switch case for visual ${humanName} already exists.`);
+        return;
+    }
+    const newCase = `case '${visualCamel}':
+          this._render${visualPascal}(visual);
+          return true`;
+    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, sourceFilePath, sourceFile.getFullText());
+    console.log(`✅ Added switch case for visual ${humanName}`);
+}
+/**
+ * Adds a new visual type entry to the `visualTypes` object within the constructor's super call.
+ */
+function addVisualTypesToConstructor(sourceFilePath, tree, vars, project, isSingleOccurrence) {
+    const sourceFile = (0, visual_utils_1.loadSourceFile)(tree, sourceFilePath, project);
+    const { visualName__camelCase: visualCamel, visualName__humanReadable: humanName, runtimeVisualSchema, } = vars;
+    const clazz = (0, visual_utils_1.findFirstClass)(sourceFile);
+    const constructor = (0, visual_utils_1.findFirstConstructor)(clazz);
+    const superCall = (0, visual_utils_1.findSuperCall)(constructor);
+    const objectLiteral = (0, visual_utils_1.getObjectLiteralFromFirstArg)(superCall);
+    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}`);
+    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)) {
+        console.log(`⚠️ Visual type for visual ${humanName} already exists.`);
+        return;
+    }
+    visualTypesObject.addPropertyAssignment({
+        name: `'${visualCamel}'`, // Ensure the key is consistently quoted for string literals
+        initializer: `{ singleton: ${isSingleOccurrence}, schema: ${runtimeVisualSchema} }`,
+    });
+    (0, visual_utils_1.saveSourceFile)(tree, sourceFilePath, sourceFile.getFullText());
+    console.log(`✅ Added visual type for ${humanName} to visualTypes.`);
+}
+/**
+ * Adds a private render method to the main class in the runtime file.
+ * Uses Nx's generateFiles for proper template processing.
+ */
+function addRenderMethod(sourceFilePath, tree, vars, project) {
+    const sourceFile = (0, visual_utils_1.loadSourceFile)(tree, sourceFilePath, project);
+    const methodName = `_render${vars.visualName__pascalCase}`;
+    const clazz = (0, visual_utils_1.findFirstClass)(sourceFile);
+    // Check if method already exists.
+    const exists = clazz
+        .getInstanceMethods()
+        .some((m) => m.getName() === methodName);
+    if (exists) {
+        console.log(`⚠️ Method ${methodName} already exists.`);
+        return;
+    }
+    // Use Nx's generateFiles to process the template to a temporary location
+    const tempDir = 'temp-render-method';
+    (0, devkit_1.generateFiles)(tree, path.join(__dirname, 'files'), tempDir, {
+        ...vars,
+        tmpl: '', // This removes the .template extension
+    });
+    // Read the processed template content
+    const processedContent = (0, visual_utils_1.readTreeFile)(tree, `${tempDir}/render-method`);
+    // Clean up the temporary file
+    tree.delete(`${tempDir}/render-method`);
+    // Add the private method to the class using ts-morph's addMethod
+    clazz.addMethod({
+        name: methodName,
+        parameters: [{ name: 'visual', type: 'HtmlDomRuntimeVisual<Root>' }],
+        statements: processedContent,
+        scope: ts_morph_1.Scope.Private,
+    });
+    // Check if ThemeProvider import exists, add if missing
+    const themeProviderImportExists = sourceFile
+        .getImportDeclarations()
+        .some((decl) => decl.getModuleSpecifier().getLiteralValue() ===
+        '@kaltura/ds-react-theme' &&
+        decl.getNamedImports().some((imp) => imp.getName() === 'ThemeProvider'));
+    if (!themeProviderImportExists) {
+        sourceFile.addImportDeclaration({
+            kind: ts_morph_1.StructureKind.ImportDeclaration,
+            namedImports: ['ThemeProvider'],
+            moduleSpecifier: '@kaltura/ds-react-theme',
+        });
+        console.log(`✅ Added ThemeProvider import to ${sourceFilePath}`);
+    }
+    (0, visual_utils_1.saveSourceFile)(tree, sourceFilePath, sourceFile.getFullText());
+    console.log(`✅ Added render method ${methodName}.`);
+}
+/**
+ * Adds an interface and schema definition to the core runtime types file.
+ */
+function addVariablesInCore(tree, vars) {
+    const coreFile = `unisphere/packages/core/src/lib/${vars.runtimeName__lowerDashCase}-runtime/runtime-types.ts`;
+    if (!tree.exists(coreFile)) {
+        throw new Error(`Core file not found at ${coreFile}`);
+    }
+    const currentContent = (0, visual_utils_1.readTreeFile)(tree, coreFile);
+    const { runtimeVisualSettings: interfaceName, runtimeVisualSchema: schemaName, visualName__humanReadable: humanName, } = vars;
+    // Check if the interface already exists to prevent duplicates.
+    if (currentContent.includes(`export interface ${interfaceName}`)) {
+        console.log(`⚠️ Interface ${interfaceName} already exists in core file.`);
+        return;
+    }
+    // Construct the new interface and schema content.
+    const newContent = `
+export interface ${interfaceName} {
+  schemaVersion?: string;
+}
+
+export const ${schemaName}: ValidatorSchema = {
+  type: 'object',
+  properties: {
+    schemaVersion: { type: 'literal', value: '1', optional: true },
+  },
+};
+`;
+    // Append the new content to the file.
+    tree.write(coreFile, currentContent + newContent);
+    console.log(`✅ Added interface and schema for ${humanName} to core file.`);
+}
+/* -------------------------------------------
+ * Entry Point (Main generator function)
+ * -----------------------------------------*/
+/**
+ * Nx generator to create a new visual within a specified runtime.
+ */
+async function addVisualGenerator(tree, options) {
+    const { runtimeName, visualName, isSingleOccurrence } = options;
+    const unisphereConfig = (0, utils_1.validateUnisphereConfig)(tree);
+    // 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`;
+    // Get core package alias and compute various name transforms.
+    const coreAlias = (0, utils_1.findCorePackageAlias)(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,
+        ...widgetNames,
+        runtimeVisualSettings,
+        runtimeVisualSchema,
+        coreAlias,
+    };
+    // 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);
+    // 'project' parameter is not needed here as addVariablesInCore directly writes to the tree.
+    addVariablesInCore(tree, templateVariables);
+    // 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}'!`);
+    console.log(`   Runtime: ${runtimeName} (${runtimeSourceRoot})`);
+    console.log(`   Visual: ${visualName}`);
+    console.log(`   Single occurrence: ${isSingleOccurrence ? 'Yes' : 'No'}`);
+    console.log(`   Modified file: ${runtimeTSxPath}`);
+}
+exports.default = addVisualGenerator;

package/dist/generators/add-visual/files/render-method.template

@@ -0,0 +1,31 @@
+  if (!this._theme) {
+    this._logger.log('cannot render <%= visualName__humanReadable %> - theme not available');
+    return;
+  }
+
+  // It is safe to assume the settings type here as it was already validated by the base class
+  const visualSettings: <%= runtimeName__pascalCase %>Runtime<%= visualName__pascalCase %>VisualSettings = visual.settings as unknown as <%= runtimeName__pascalCase %>Runtime<%= visualName__pascalCase %>VisualSettings;
+
+  this._logger.log('rendering <%= visualName__humanReadable %>');
+
+  visual.htmlContainer?.render(
+    <ScopedUnisphereWorkspaceProvider unisphereWorkspace={this._workspace}>
+      <ThemeProvider
+        cssPrefix={'<%= widgetName__lowerDashCase %>-<%= runtimeName__lowerDashCase %>-<%= visualName__lowerDashCase %>'}
+        mode={typeof this._theme === 'string' ? this._theme : this._theme.mode}
+        overrides={typeof this._theme === 'string' ? undefined : this._theme}
+        style={{
+          width: '100%',
+          display: 'flex',
+          alignItems: 'center',
+          justifyContent: 'center',
+          overflow: 'hidden',
+        }}
+        className={'unisphere-<%= widgetName__lowerDashCase %>-<%= runtimeName__lowerDashCase %>'}
+      >
+        <div>
+          {/* TODO: Add your <%= visualName__humanReadable %> implementation here */}
+        </div>
+      </ThemeProvider>
+    </ScopedUnisphereWorkspaceProvider>
+  );

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

@@ -0,0 +1,5 @@
+export interface AddVisualGeneratorSchema {
+  runtimeName: string;
+  visualName: string;
+  isSingleOccurrence: boolean;
+}

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

@@ -0,0 +1,30 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "AddVisual",
+  "title": "Add Visual Generator",
+  "type": "object",
+  "properties": {
+    "runtimeName": {
+      "type": "string",
+      "description": "Name of the runtime",
+      "x-prompt": "What is the runtime name?"
+    },
+    "visualName": {
+      "type": "string",
+      "description": "Name of the visual",
+      "x-prompt": "What is the visual name?"
+    },
+    "isSingleOccurrence": {
+      "type": "boolean",
+      "description": "Is this visual limited to single occurrence?",
+      "x-prompt": {
+        "message": "Is this visual limited to single occurrence?",
+        "type": "confirmation"
+      }
+    }
+  },
+  "required": [
+    "runtimeName",
+    "isSingleOccurrence"
+  ]
+}

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

@@ -0,0 +1,42 @@
+import { Tree } from '@nx/devkit';
+import { CallExpression, ClassDeclaration, ConstructorDeclaration, ObjectLiteralExpression, Project, SourceFile } from 'ts-morph';
+/**
+ * Reads the content of a file from the Nx Tree.
+ * Throws an error if the file cannot be read.
+ */
+export declare function readTreeFile(tree: Tree, filePath: string): string;
+/**
+ * Loads a file from the Nx Tree into a ts-morph Project.
+ * Uses `readTreeFile` to get content.
+ */
+export declare function loadSourceFile(tree: Tree, filePath: string, project: Project): SourceFile;
+/**
+ * Saves the updated source file content back to the Nx Tree.
+ */
+export declare function saveSourceFile(tree: Tree, filePath: string, sourceFileContent: string): void;
+/**
+ * Throws an error if the provided item is null or undefined.
+ * Returns the item with a non-null/undefined type assertion.
+ */
+export declare function throwIfNotFound<T>(item: T | null | undefined, message: string): T;
+/**
+ * Checks if a property exists in an ObjectLiteralExpression, handling quoted keys.
+ */
+export declare function propertyExists(objectLiteral: ObjectLiteralExpression, propName: string): boolean;
+/**
+ * Finds the first ClassDeclaration in a SourceFile.
+ */
+export declare function findFirstClass(sourceFile: SourceFile): ClassDeclaration;
+/**
+ * Finds the first ConstructorDeclaration in a ClassDeclaration.
+ */
+export declare function findFirstConstructor(clazz: ClassDeclaration): ConstructorDeclaration;
+/**
+ * Finds the `super()` CallExpression within a ConstructorDeclaration.
+ */
+export declare function findSuperCall(constructor: ConstructorDeclaration): CallExpression;
+/**
+ * Gets the first argument of a CallExpression, asserting it's an ObjectLiteralExpression.
+ */
+export declare function getObjectLiteralFromFirstArg(callExpression: CallExpression): ObjectLiteralExpression;
+//# sourceMappingURL=visual-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"visual-utils.d.ts","sourceRoot":"","sources":["../../../src/generators/add-visual/visual-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAClC,OAAO,EACH,cAAc,EACd,gBAAgB,EAChB,sBAAsB,EACtB,uBAAuB,EACvB,OAAO,EAEP,UAAU,EAEb,MAAM,UAAU,CAAC;AAOlB;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAM/D;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,GACf,UAAU,CAGZ;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAChB,iBAAiB,EAAE,MAAM,GACxB,IAAI,CAGN;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC,CAKjF;AAID;;GAEG;AACH,wBAAgB,cAAc,CAC5B,aAAa,EAAE,uBAAuB,EACtC,QAAQ,EAAE,MAAM,GACf,OAAO,CAUT;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,UAAU,GAAG,gBAAgB,CAMvE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,gBAAgB,GAAG,sBAAsB,CAMpF;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,sBAAsB,GAAG,cAAc,CAQjF;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,cAAc,EAAE,cAAc,GAC7B,uBAAuB,CAUzB"}

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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readTreeFile = readTreeFile;
+exports.loadSourceFile = loadSourceFile;
+exports.saveSourceFile = saveSourceFile;
+exports.throwIfNotFound = throwIfNotFound;
+exports.propertyExists = propertyExists;
+exports.findFirstClass = findFirstClass;
+exports.findFirstConstructor = findFirstConstructor;
+exports.findSuperCall = findSuperCall;
+exports.getObjectLiteralFromFirstArg = getObjectLiteralFromFirstArg;
+const ts_morph_1 = require("ts-morph");
+/* -------------------------------------------
+ * Utilities
+ * -----------------------------------------*/
+/**
+ * Reads the content of a file from the Nx Tree.
+ * Throws an error if the file cannot be read.
+ */
+function readTreeFile(tree, filePath) {
+    const content = tree.read(filePath, 'utf-8');
+    if (!content) {
+        throw new Error(`Could not read file at ${filePath}`);
+    }
+    return content;
+}
+/**
+ * Loads a file from the Nx Tree into a ts-morph Project.
+ * Uses `readTreeFile` to get content.
+ */
+function loadSourceFile(tree, filePath, project) {
+    const content = readTreeFile(tree, filePath);
+    return project.createSourceFile(filePath, content, { overwrite: true });
+}
+/**
+ * Saves the updated source file content back to the Nx Tree.
+ */
+function saveSourceFile(tree, filePath, sourceFileContent) {
+    tree.write(filePath, sourceFileContent);
+    console.log(`✅ Updated ${filePath}`);
+}
+/**
+ * Throws an error if the provided item is null or undefined.
+ * Returns the item with a non-null/undefined type assertion.
+ */
+function throwIfNotFound(item, message) {
+    if (item === null || item === undefined) {
+        throw new Error(message);
+    }
+    return item;
+}
+/**
+ * Checks if a property exists in an ObjectLiteralExpression, handling quoted keys.
+ */
+function propertyExists(objectLiteral, propName) {
+    return objectLiteral.getProperties().some((prop) => {
+        if (prop.getKind() === ts_morph_1.SyntaxKind.PropertyAssignment) {
+            const assignment = prop;
+            // Get the text of the property name node, and remove any quotes
+            const name = assignment.getNameNode().getText().replace(/['"]/g, '');
+            return name === propName;
+        }
+        return false;
+    });
+}
+/**
+ * Finds the first ClassDeclaration in a SourceFile.
+ */
+function findFirstClass(sourceFile) {
+    const clazz = sourceFile.getClasses()[0];
+    return throwIfNotFound(clazz, `No class found in ${sourceFile.getFilePath()}`);
+}
+/**
+ * Finds the first ConstructorDeclaration in a ClassDeclaration.
+ */
+function findFirstConstructor(clazz) {
+    const constructor = clazz.getConstructors()[0];
+    return throwIfNotFound(constructor, `No constructor found in class ${clazz.getName() || ''}`);
+}
+/**
+ * Finds the `super()` CallExpression within a ConstructorDeclaration.
+ */
+function findSuperCall(constructor) {
+    const superCall = constructor
+        .getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)
+        .find((call) => call.getExpression().getKind() === ts_morph_1.SyntaxKind.SuperKeyword);
+    return throwIfNotFound(superCall, `Could not find super() call in constructor.`);
+}
+/**
+ * Gets the first argument of a CallExpression, asserting it's an ObjectLiteralExpression.
+ */
+function getObjectLiteralFromFirstArg(callExpression) {
+    const args = callExpression.getArguments();
+    throwIfNotFound(args.length, `Call expression has no arguments.`);
+    const objectLiteral = args[0];
+    throwIfNotFound(objectLiteral &&
+        objectLiteral.getKind() === ts_morph_1.SyntaxKind.ObjectLiteralExpression, `First argument is not an object literal.`);
+    return objectLiteral;
+}

package/dist/generators/utils.d.ts

@@ -0,0 +1,18 @@
+import { Tree } from '@nx/devkit';
+export interface UnisphereConfig {
+    company: string;
+    name: string;
+}
+export declare function validateUnisphereConfig(tree: Tree): UnisphereConfig;
+export declare function updateTsConfigPaths(tree: Tree, pathKey: string, pathValue: string): void;
+export declare function updateUnisphereConfig(tree: Tree, elementType: 'packages' | 'runtimes' | 'applications', elementName: string, elementConfig: Record<string, any>): void;
+export declare function validateRuntimeExists(tree: Tree, runtimeName: string): string;
+export declare function findCorePackageAlias(tree: Tree): string;
+type NameTransformations<Prefix extends string> = {
+    [K in `${Prefix}` | `${Prefix}__lowerDashCase` | `${Prefix}__camelCase` | `${Prefix}__pascalCase` | `${Prefix}__constantCase` | `${Prefix}__humanReadable`]: string;
+};
+export declare function createNameTransforms<Prefix extends string>(baseName: string, prefix: Prefix): NameTransformations<Prefix>;
+export declare function isPackageInstalled(tree: Tree, packageName: string): string | false;
+export declare function checkIfRuntimeExists(tree: Tree, runtimeName: string): boolean;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/generators/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/generators/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EAKL,MAAM,YAAY,CAAC;AAGpB,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,IAAI,GAAG,eAAe,CAmDnE;AAGD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,QA4BjF;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,UAAU,GAAG,UAAU,GAAG,cAAc,EACrD,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,QA2BnC;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CA6C7E;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CA8BvD;AAGD,KAAK,mBAAmB,CAAC,MAAM,SAAS,MAAM,IAAI;KAC/C,CAAC,IACE,GAAG,MAAM,EAAE,GACX,GAAG,MAAM,iBAAiB,GAC1B,GAAG,MAAM,aAAa,GACtB,GAAG,MAAM,cAAc,GACvB,GAAG,MAAM,gBAAgB,GACzB,GAAG,MAAM,iBAAiB,GAAG,MAAM;CACxC,CAAC;AAKF,wBAAgB,oBAAoB,CAAC,MAAM,SAAS,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,mBAAmB,CAAC,MAAM,CAAC,CAczH;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAwBlF;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAgB7E"}

package/dist/generators/utils.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateUnisphereConfig = validateUnisphereConfig;
+exports.updateTsConfigPaths = updateTsConfigPaths;
+exports.updateUnisphereConfig = updateUnisphereConfig;
+exports.validateRuntimeExists = validateRuntimeExists;
+exports.findCorePackageAlias = findCorePackageAlias;
+exports.createNameTransforms = createNameTransforms;
+exports.isPackageInstalled = isPackageInstalled;
+exports.checkIfRuntimeExists = checkIfRuntimeExists;
+const devkit_1 = require("@nx/devkit");
+function validateUnisphereConfig(tree) {
+    // Check if file exists
+    if (!tree.exists('.unisphere')) {
+        throw new Error('Missing .unisphere configuration file in root project.\n' +
+            'Please create .unisphere with the following structure:\n' +
+            '{\n' +
+            '  "company": "Your Company Name",\n' +
+            '  "name": "your-experience-name"\n' +
+            '}');
+    }
+    // Read and parse JSON
+    let config;
+    try {
+        config = (0, devkit_1.readJson)(tree, '.unisphere');
+    }
+    catch (error) {
+        throw new Error(`Failed to read .unisphere: ${error instanceof Error ? error.message : 'Unknown error'}\n` + 'Please ensure the file contains valid JSON.');
+    }
+    // Validate required fields
+    const missingFields = [];
+    if (!config.company) {
+        missingFields.push('"company"');
+    }
+    if (!config.name) {
+        missingFields.push('"name"');
+    }
+    if (missingFields.length > 0) {
+        throw new Error(`Missing required field${missingFields.length > 1 ? 's' : ''} ${missingFields.join(' and ')} in .unisphere.\n` +
+            'Please ensure your .unisphere contains:\n' +
+            '{\n' +
+            '  "company": "Your Company Name",\n' +
+            '  "name": "your-experience-name"\n' +
+            '}');
+    }
+    return {
+        company: config.company,
+        name: config.name,
+    };
+}
+function updateTsConfigPaths(tree, pathKey, pathValue) {
+    if (tree.exists('tsconfig.base.json')) {
+        try {
+            const tsconfigBase = (0, devkit_1.readJson)(tree, 'tsconfig.base.json');
+            // Ensure compilerOptions and paths exist
+            if (!tsconfigBase.compilerOptions) {
+                tsconfigBase.compilerOptions = {};
+            }
+            if (!tsconfigBase.compilerOptions.paths) {
+                tsconfigBase.compilerOptions.paths = {};
+            }
+            // Add the path mapping (only if it doesn't already exist)
+            if (!tsconfigBase.compilerOptions.paths[pathKey]) {
+                tsconfigBase.compilerOptions.paths[pathKey] = [pathValue];
+            }
+            // Write the updated tsconfig back
+            (0, devkit_1.writeJson)(tree, 'tsconfig.base.json', tsconfigBase);
+        }
+        catch (error) {
+            throw new Error(`Failed to update tsconfig.base.json: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+}
+function updateUnisphereConfig(tree, elementType, elementName, elementConfig) {
+    const existingConfig = (0, devkit_1.readJson)(tree, '.unisphere');
+    // Ensure elements structure exists
+    if (!existingConfig.elements) {
+        existingConfig.elements = {};
+    }
+    if (!existingConfig.elements[elementType]) {
+        existingConfig.elements[elementType] = {};
+    }
+    // Add the new element entry (only if it doesn't already exist)
+    if (!existingConfig.elements[elementType][elementName]) {
+        existingConfig.elements[elementType][elementName] = elementConfig;
+    }
+    // Write the updated configuration back
+    try {
+        (0, devkit_1.writeJson)(tree, '.unisphere', existingConfig);
+    }
+    catch (error) {
+        throw new Error(`Failed to update .unisphere: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+function validateRuntimeExists(tree, runtimeName) {
+    // First validate that .unisphere exists
+    if (!tree.exists('.unisphere')) {
+        throw new Error('Missing .unisphere configuration file in root project.');
+    }
+    // Read and parse the .unisphere configuration
+    let config;
+    try {
+        config = (0, devkit_1.readJson)(tree, '.unisphere');
+    }
+    catch (error) {
+        throw new Error(`Failed to read .unisphere: ${error instanceof Error ? error.message : 'Unknown error'}\n` + 'Please ensure the file contains valid JSON.');
+    }
+    // Check if elements.runtimes exists
+    if (!config.elements?.runtimes) {
+        throw new Error(`No runtimes found in .unisphere configuration.\n` +
+            `Runtime "${runtimeName}" not found.\n` +
+            'Please create a runtime first using: nx generate @unisphere/nx:add-runtime');
+    }
+    // Check if the specific runtime exists
+    const runtimeConfig = config.elements.runtimes[runtimeName];
+    if (!runtimeConfig) {
+        throw new Error(`Runtime "${runtimeName}" not found in .unisphere configuration.`);
+    }
+    // Check if sourceRoot exists
+    if (!runtimeConfig.sourceRoot) {
+        throw new Error(`Runtime "${runtimeName}" exists but has no sourceRoot configured`);
+    }
+    return runtimeConfig.sourceRoot;
+}
+function findCorePackageAlias(tree) {
+    if (!tree.exists('tsconfig.base.json')) {
+        throw new Error('tsconfig.base.json not found in the project root.');
+    }
+    try {
+        const tsconfigBase = (0, devkit_1.readJson)(tree, 'tsconfig.base.json');
+        if (!tsconfigBase.compilerOptions?.paths) {
+            throw new Error('No paths found in tsconfig.base.json compilerOptions.');
+        }
+        // Find the key that has the value "unisphere/packages/core/src/index.ts"
+        for (const [key, paths] of Object.entries(tsconfigBase.compilerOptions.paths)) {
+            if (Array.isArray(paths) && paths.includes('unisphere/packages/core/src/index.ts')) {
+                return key;
+            }
+        }
+        throw new Error('Core package not found in tsconfig.base.json paths. ' +
+            'Expected to find a key with value "unisphere/packages/core/src/index.ts"');
+    }
+    catch (error) {
+        throw new Error(`Failed to read tsconfig.base.json: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+function createNameTransforms(baseName, prefix) {
+    const nameVariants = (0, devkit_1.names)(baseName); // Assuming 'names' function is available and returns NameVariants
+    const humanReadable = baseName
+        .replace(/[-_]/g, ' ')
+        .replace(/\b\w/g, (l) => l.toUpperCase());
+    return {
+        [`${prefix}`]: baseName,
+        [`${prefix}__lowerDashCase`]: nameVariants.fileName,
+        [`${prefix}__camelCase`]: nameVariants.propertyName,
+        [`${prefix}__pascalCase`]: nameVariants.className,
+        [`${prefix}__constantCase`]: nameVariants.constantName,
+        [`${prefix}__humanReadable`]: humanReadable,
+    }; // Type assertion to match the defined type
+}
+function isPackageInstalled(tree, packageName) {
+    // Check if package.json exists
+    if (!tree.exists('package.json')) {
+        devkit_1.logger.warn('⚠️ package.json not found in root directory');
+        return false;
+    }
+    try {
+        const packageJson = (0, devkit_1.readJson)(tree, 'package.json');
+        // Check all dependency types
+        const allDependencies = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies,
+            ...packageJson.peerDependencies,
+        };
+        const installedVersion = allDependencies[packageName];
+        return installedVersion || false;
+    }
+    catch (error) {
+        devkit_1.logger.warn(`⚠️ Failed to read package.json: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        return false;
+    }
+}
+function checkIfRuntimeExists(tree, runtimeName) {
+    // Check if .unisphere file exists
+    if (!tree.exists('.unisphere')) {
+        return false;
+    }
+    try {
+        // Read and parse the .unisphere configuration
+        const config = (0, devkit_1.readJson)(tree, '.unisphere');
+        // Check if elements.runtimes exists and contains the runtime
+        return !!(config.elements?.runtimes?.[runtimeName]);
+    }
+    catch (error) {
+        // If there's any error reading/parsing the file, return false
+        return false;
+    }
+}