@nx/angular 0.0.0-pr-22179-271588f

package/src/generators/utils/storybook-ast/component-info.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStandaloneComponentsInfo = exports.getComponentsInfo = void 0;
+const devkit_1 = require("@nx/devkit");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+const path_1 = require("path");
+const ast_utils_1 = require("../../../utils/nx-devkit/ast-utils");
+const module_info_1 = require("./module-info");
+const tree_utilities_1 = require("./tree-utilities");
+let tsModule;
+let tsquery;
+function getComponentsInfo(tree, entryPoint, moduleFilePaths, projectName) {
+    return moduleFilePaths
+        .flatMap((moduleFilePath) => {
+        const file = (0, ast_utils_1.getTsSourceFile)(tree, moduleFilePath);
+        const declaredComponents = (0, module_info_1.getModuleDeclaredComponents)(file, moduleFilePath, projectName);
+        if (declaredComponents.length === 0) {
+            return undefined;
+        }
+        if (!tsModule) {
+            tsModule = (0, ensure_typescript_1.ensureTypescript)();
+        }
+        const imports = file.statements.filter((statement) => statement.kind === tsModule.SyntaxKind.ImportDeclaration);
+        const componentsInfo = declaredComponents.map((componentName) => getComponentInfo(tree, entryPoint, file, imports, moduleFilePath, componentName));
+        return componentsInfo;
+    })
+        .filter((f) => f !== undefined);
+}
+exports.getComponentsInfo = getComponentsInfo;
+function getStandaloneComponentsInfo(tree, entryPoint) {
+    const componentsInfo = [];
+    (0, devkit_1.visitNotIgnoredFiles)(tree, entryPoint.path, (filePath) => {
+        const normalizedFilePath = (0, devkit_1.normalizePath)(filePath);
+        if (entryPoint.excludeDirs?.some((excludeDir) => normalizedFilePath.startsWith(excludeDir))) {
+            return;
+        }
+        if ((0, path_1.extname)(normalizedFilePath) !== '.ts' ||
+            normalizedFilePath.includes('.storybook')) {
+            return;
+        }
+        const standaloneComponents = getStandaloneComponents(tree, normalizedFilePath);
+        if (!standaloneComponents.length) {
+            return;
+        }
+        standaloneComponents.forEach((componentName) => {
+            componentsInfo.push({
+                componentFileName: (0, path_1.basename)(normalizedFilePath, '.ts'),
+                moduleFolderPath: entryPoint.path,
+                name: componentName,
+                path: (0, path_1.dirname)((0, path_1.relative)(entryPoint.path, normalizedFilePath)),
+                entryPointName: entryPoint.name,
+            });
+        });
+    });
+    return componentsInfo;
+}
+exports.getStandaloneComponentsInfo = getStandaloneComponentsInfo;
+function getStandaloneComponents(tree, filePath) {
+    if (!tsquery) {
+        (0, ensure_typescript_1.ensureTypescript)();
+        tsquery = require('@phenomnomnominal/tsquery').tsquery;
+    }
+    const fileContent = tree.read(filePath, 'utf-8');
+    const ast = tsquery.ast(fileContent);
+    const components = tsquery(ast, 'ClassDeclaration:has(Decorator > CallExpression:has(Identifier[name=Component]) ObjectLiteralExpression PropertyAssignment Identifier[name=standalone] ~ TrueKeyword) > Identifier', { visitAllChildren: true });
+    return components.map((component) => component.getText());
+}
+function getComponentImportPath(componentName, imports) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const componentImportStatement = imports.find((statement) => {
+        const namedImports = statement
+            .getChildren()
+            .find((node) => node.kind === tsModule.SyntaxKind.ImportClause)
+            .getChildren()
+            .find((node) => node.kind === tsModule.SyntaxKind.NamedImports);
+        if (namedImports === undefined)
+            return false;
+        const importedIdentifiers = namedImports
+            .getChildren()
+            .find((node) => node.kind === tsModule.SyntaxKind.SyntaxList)
+            .getChildren()
+            .filter((node) => node.kind === tsModule.SyntaxKind.ImportSpecifier)
+            .map((node) => node.getText());
+        return importedIdentifiers.includes(componentName);
+    });
+    const importPath = componentImportStatement
+        .getChildren()
+        .find((node) => node.kind === tsModule.SyntaxKind.StringLiteral)
+        .getText()
+        .slice(1, -1);
+    return importPath;
+}
+function getComponentInfo(tree, entryPoint, sourceFile, imports, moduleFilePath, componentName) {
+    try {
+        if (!tsquery) {
+            (0, ensure_typescript_1.ensureTypescript)();
+            tsquery = require('@phenomnomnominal/tsquery').tsquery;
+        }
+        const moduleFolderPath = (0, path_1.dirname)(moduleFilePath);
+        // try to get the component from the same file (inline scam)
+        const node = tsquery(sourceFile, `ClassDeclaration:has(Decorator > CallExpression > Identifier[name=Component]):has(Identifier[name=${componentName}])`, { visitAllChildren: true })[0];
+        if (node) {
+            return {
+                componentFileName: (0, path_1.basename)(moduleFilePath, '.ts'),
+                moduleFolderPath,
+                name: componentName,
+                path: '.',
+                entryPointName: entryPoint.name,
+            };
+        }
+        // try to get the component from the imports
+        const componentFilePathRelativeToModule = getComponentImportPath(componentName, imports);
+        const componentImportPath = getFullComponentFilePath(moduleFolderPath, componentFilePathRelativeToModule);
+        if (tree.exists(componentImportPath) && !tree.isFile(componentImportPath)) {
+            return getComponentInfoFromDir(tree, entryPoint, componentImportPath, componentName, moduleFolderPath);
+        }
+        const path = (0, path_1.dirname)(componentFilePathRelativeToModule);
+        const componentFileName = (0, path_1.basename)(componentFilePathRelativeToModule);
+        return {
+            componentFileName,
+            moduleFolderPath,
+            name: componentName,
+            path,
+            entryPointName: entryPoint.name,
+        };
+    }
+    catch (ex) {
+        devkit_1.logger.warn(`Could not generate a story for ${componentName}. Error: ${ex}`);
+        return undefined;
+    }
+}
+function getComponentInfoFromDir(tree, entryPoint, dir, componentName, moduleFolderPath) {
+    let path = null;
+    let componentFileName = null;
+    const componentImportPathChildren = (0, tree_utilities_1.getAllFilesRecursivelyFromDir)(tree, dir);
+    for (const candidateFile of componentImportPathChildren) {
+        if (candidateFile.endsWith('.ts')) {
+            const content = tree.read(candidateFile, 'utf-8');
+            const classAndComponentRegex = new RegExp(`@Component[\\s\\S\n]*?\\bclass ${componentName}\\b`, 'g');
+            if (content.match(classAndComponentRegex)) {
+                path = candidateFile
+                    .slice(0, candidateFile.lastIndexOf('/'))
+                    .replace(moduleFolderPath, '.');
+                componentFileName = candidateFile.slice(candidateFile.lastIndexOf('/') + 1, candidateFile.lastIndexOf('.'));
+                break;
+            }
+        }
+    }
+    if (path === null) {
+        throw new Error(`Path to component ${componentName} couldn't be found. Please open an issue on https://github.com/nrwl/nx/issues.`);
+    }
+    return {
+        componentFileName,
+        moduleFolderPath,
+        name: componentName,
+        path,
+        entryPointName: entryPoint.name,
+    };
+}
+function getFullComponentFilePath(moduleFolderPath, componentFilePath) {
+    if (moduleFolderPath.startsWith('/')) {
+        moduleFolderPath = moduleFolderPath.slice(1, moduleFolderPath.length);
+    }
+    return (0, devkit_1.joinPathFragments)(moduleFolderPath, componentFilePath);
+}

package/src/generators/utils/storybook-ast/entry-point.d.ts

@@ -0,0 +1,7 @@
+import type { Tree } from '@nx/devkit';
+export type EntryPoint = {
+    name: string;
+    path: string;
+    excludeDirs?: string[];
+};
+export declare function getProjectEntryPoints(tree: Tree, projectName: string): EntryPoint[];

package/src/generators/utils/storybook-ast/entry-point.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectEntryPoints = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+function getProjectEntryPoints(tree, projectName) {
+    const { root, sourceRoot, projectType } = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+    const rootEntryPoint = {
+        name: '',
+        path: normalizeMainEntryPointSourceRoot(tree, root, sourceRoot, projectType),
+    };
+    const entryPointRootPaths = [rootEntryPoint];
+    if (projectType === 'application') {
+        return entryPointRootPaths;
+    }
+    collectLibrarySecondaryEntryPoints(tree, root, entryPointRootPaths);
+    // since the root includes some secondary entry points, we need to ignore
+    // them when processing the main entry point
+    if (rootEntryPoint.path === root && entryPointRootPaths.length > 1) {
+        rootEntryPoint.excludeDirs = entryPointRootPaths
+            .slice(1)
+            .map((entryPoint) => entryPoint.path);
+    }
+    return entryPointRootPaths;
+}
+exports.getProjectEntryPoints = getProjectEntryPoints;
+function collectLibrarySecondaryEntryPoints(tree, root, entryPointPaths) {
+    const exclude = new Set([`${root}/ng-package.json`, `${root}/package.json`]);
+    (0, devkit_1.visitNotIgnoredFiles)(tree, root, (path) => {
+        const normalizedPath = (0, devkit_1.normalizePath)(path);
+        if (!tree.isFile(normalizedPath) || exclude.has(normalizedPath)) {
+            return;
+        }
+        const fileName = (0, path_1.basename)(normalizedPath);
+        if (fileName !== 'ng-package.json' &&
+            (fileName !== 'package.json' ||
+                (fileName === 'package.json' &&
+                    !(0, devkit_1.readJson)(tree, normalizedPath).ngPackage))) {
+            return;
+        }
+        const entryPointPath = getSourcePath(tree, (0, devkit_1.normalizePath)((0, path_1.dirname)(normalizedPath)), 'lib');
+        entryPointPaths.push({
+            name: (0, path_1.basename)((0, path_1.dirname)(normalizedPath)),
+            path: entryPointPath,
+        });
+    });
+}
+function normalizeMainEntryPointSourceRoot(tree, root, sourceRoot, projectType) {
+    const projectTypeDir = projectType === 'application' ? 'app' : 'lib';
+    if (sourceRoot) {
+        return [(0, devkit_1.joinPathFragments)(sourceRoot, projectTypeDir), sourceRoot].find((path) => tree.exists(path));
+    }
+    return getSourcePath(tree, root, projectTypeDir) ?? root;
+}
+function getSourcePath(tree, basePath, projectTypeDir) {
+    const candidatePaths = [
+        (0, devkit_1.joinPathFragments)(basePath, 'src', projectTypeDir),
+        (0, devkit_1.joinPathFragments)(basePath, 'src'),
+        (0, devkit_1.joinPathFragments)(basePath, projectTypeDir),
+        basePath,
+    ];
+    return candidatePaths.find((candidatePath) => tree.exists(candidatePath));
+}

package/src/generators/utils/storybook-ast/module-info.d.ts

@@ -0,0 +1,5 @@
+import type { Tree } from '@nx/devkit';
+import type { SourceFile } from 'typescript';
+import type { EntryPoint } from './entry-point';
+export declare function getModuleDeclaredComponents(file: SourceFile, moduleFilePath: string, projectName: string): string[];
+export declare function getModuleFilePaths(tree: Tree, entryPoint: EntryPoint): string[];

package/src/generators/utils/storybook-ast/module-info.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModuleFilePaths = exports.getModuleDeclaredComponents = void 0;
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+const path_1 = require("path");
+const ast_utils_1 = require("../../../utils/nx-devkit/ast-utils");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+let tsModule;
+function getModuleDeclaredComponents(file, moduleFilePath, projectName) {
+    const ngModuleDecorator = getNgModuleDecorator(file, moduleFilePath);
+    const declarationsPropertyAssignment = getNgModuleDeclarationsPropertyAssignment(ngModuleDecorator, moduleFilePath, projectName);
+    if (!declarationsPropertyAssignment) {
+        return [];
+    }
+    const declarationsArray = getDeclarationsArray(file, declarationsPropertyAssignment, moduleFilePath, projectName);
+    if (!declarationsArray) {
+        return [];
+    }
+    return getDeclaredComponentsInDeclarations(declarationsArray);
+}
+exports.getModuleDeclaredComponents = getModuleDeclaredComponents;
+function getModuleFilePaths(tree, entryPoint) {
+    let moduleFilePaths = [];
+    (0, devkit_1.visitNotIgnoredFiles)(tree, entryPoint.path, (filePath) => {
+        const normalizedFilePath = (0, devkit_1.normalizePath)(filePath);
+        if (entryPoint.excludeDirs?.some((excludeDir) => normalizedFilePath.startsWith(excludeDir))) {
+            return;
+        }
+        if ((0, path_1.extname)(normalizedFilePath) === '.ts' &&
+            !normalizedFilePath.includes('.storybook') &&
+            hasNgModule(tree, normalizedFilePath)) {
+            moduleFilePaths.push(normalizedFilePath);
+        }
+    });
+    return moduleFilePaths;
+}
+exports.getModuleFilePaths = getModuleFilePaths;
+function hasNgModule(tree, filePath) {
+    (0, ensure_typescript_1.ensureTypescript)();
+    const { tsquery } = require('@phenomnomnominal/tsquery');
+    const fileContent = tree.read(filePath, 'utf-8');
+    const ast = tsquery.ast(fileContent);
+    const ngModule = tsquery(ast, 'ClassDeclaration > Decorator > CallExpression > Identifier[name=NgModule]', { visitAllChildren: true });
+    return ngModule.length > 0;
+}
+function getDeclaredComponentsInDeclarations(declarationsArray) {
+    return getDeclaredComponentNodes(declarationsArray)
+        .map((node) => node.getText())
+        .filter((name) => name.endsWith('Component'));
+}
+function getDeclaredComponentNodes(declarationsArray) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const cmps = declarationsArray
+        .getChildren()
+        .find((node) => node.kind === tsModule.SyntaxKind.SyntaxList)
+        .getChildren()
+        .map((node) => {
+        if (node.kind === tsModule.SyntaxKind.Identifier) {
+            return node;
+        }
+        // if the node is a destructuring, follow the variable
+        if (node.kind === tsModule.SyntaxKind.SpreadElement) {
+            const declarationVariableNode = node
+                .getChildren()
+                .find((node) => node.kind === tsModule.SyntaxKind.Identifier);
+            // try to find the variable declaration in the same component
+            const declarationVariable = getVariableDeclaration(declarationVariableNode.getText(), declarationVariableNode.getSourceFile());
+            if (declarationVariable &&
+                declarationVariable.initializer.kind ===
+                    tsModule.SyntaxKind.ArrayLiteralExpression) {
+                const nodes = getDeclaredComponentNodes(declarationVariable.initializer);
+                return nodes;
+            }
+        }
+        return null;
+    })
+        .filter((node) => !!node);
+    return flatten(cmps);
+}
+function flatten(arr) {
+    let flattened = [];
+    for (const entry of arr) {
+        if (Array.isArray(entry)) {
+            flattened.push(...flatten(entry));
+        }
+        else {
+            flattened.push(entry);
+        }
+    }
+    return flattened;
+}
+function getDeclarationsArray(file, declarationsPropertyAssignment, moduleFilePath, projectName) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    let declarationArray = declarationsPropertyAssignment
+        .getChildren()
+        .find((node) => node.kind === tsModule.SyntaxKind.ArrayLiteralExpression);
+    if (declarationArray) {
+        return declarationArray;
+    }
+    // Attempt to follow a variable instead of the literal
+    declarationArray = getModuleDeclaredComponentsFromVariable(file, declarationsPropertyAssignment);
+    if (declarationArray) {
+        return declarationArray;
+    }
+    // Attempt to follow a class declaration instead of the literal
+    declarationArray = getModuleDeclaredComponentsFromClass(file, declarationsPropertyAssignment);
+    if (!declarationArray) {
+        devkit_1.logger.warn((0, devkit_1.stripIndents) `No stories generated because the declarations in ${moduleFilePath} is not an array literal or the variable could not be found. Hint: you can always generate stories later with the 'nx generate @nx/angular:stories --name=${projectName}' command.`);
+    }
+    return declarationArray;
+}
+/**
+ * Try to get declared components like `declarations: someComponentsArrayConst`
+ */
+function getModuleDeclaredComponentsFromVariable(file, declarationsPropertyAssignment) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    let declarationsVariable = declarationsPropertyAssignment
+        .getChildren()
+        .filter((node) => node.kind === tsModule.SyntaxKind.Identifier)[1];
+    if (!declarationsVariable) {
+        return undefined;
+    }
+    // Attempt to find variable declaration in the file
+    let variableDeclaration = getVariableDeclaration(declarationsVariable.getText(), file);
+    if (!variableDeclaration) {
+        return undefined;
+    }
+    const declarationArray = variableDeclaration
+        .getChildren()
+        .find((node) => node.kind === tsModule.SyntaxKind.ArrayLiteralExpression);
+    return declarationArray;
+}
+/**
+ * Try to get declared components like `declarations: SomeClass.components` as in
+ * https://github.com/nrwl/nx/issues/7276.
+ */
+function getModuleDeclaredComponentsFromClass(file, declarationsPropertyAssignment) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const propertyAccessExpression = declarationsPropertyAssignment
+        .getChildren()
+        .filter((node) => node.kind === tsModule.SyntaxKind.PropertyAccessExpression)[0];
+    if (!propertyAccessExpression) {
+        return undefined;
+    }
+    // Should contain 2 identifiers [SomeClass, components]
+    const [clazz, componentsProperty] = propertyAccessExpression
+        .getChildren()
+        .filter((node) => node.kind === tsModule.SyntaxKind.Identifier);
+    if (!clazz || !componentsProperty) {
+        return undefined;
+    }
+    // Attempt to find class declaration in the file
+    let classDeclaration = getClassDeclaration(clazz.getText(), file);
+    if (!classDeclaration) {
+        return undefined;
+    }
+    const declarationArray = classDeclaration.members
+        .filter((node) => node.kind === tsModule.SyntaxKind.PropertyDeclaration)
+        .find((propertyDeclaration) => propertyDeclaration
+        .getChildren()
+        .find((node) => node.kind === tsModule.SyntaxKind.Identifier &&
+        node.getText() === componentsProperty.getText()))
+        .getChildren()
+        .find((node) => node.kind === tsModule.SyntaxKind.ArrayLiteralExpression);
+    return declarationArray;
+}
+function getClassDeclaration(className, file) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const classDeclaration = (0, js_1.findNodes)(file, tsModule.SyntaxKind.ClassDeclaration).find((classDeclaration) => classDeclaration
+        .getChildren()
+        .find((node) => node.kind === tsModule.SyntaxKind.Identifier &&
+        node.getText() === className));
+    return classDeclaration;
+}
+function getVariableDeclaration(variableName, file) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const variableDeclaration = (0, js_1.findNodes)(file, tsModule.SyntaxKind.VariableDeclaration).find((variableDeclaration) => variableDeclaration
+        .getChildren()
+        .find((node) => node.kind === tsModule.SyntaxKind.Identifier &&
+        node.getText() === variableName));
+    return variableDeclaration;
+}
+function getNgModuleDeclarationsPropertyAssignment(ngModuleDecorator, moduleFilePath, projectName) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const syntaxList = ngModuleDecorator.getChildren().find((node) => {
+        return node.kind === tsModule.SyntaxKind.SyntaxList;
+    });
+    const declarationsPropertyAssignment = syntaxList
+        .getChildren()
+        .find((node) => {
+        return (node.kind === tsModule.SyntaxKind.PropertyAssignment &&
+            node.getChildren()[0].getText() === 'declarations');
+    });
+    if (!declarationsPropertyAssignment) {
+        devkit_1.logger.warn((0, devkit_1.stripIndents) `No stories generated because there were no components declared in ${moduleFilePath}. Hint: you can always generate stories later with the 'nx generate @nx/angular:stories --name=${projectName}' command.`);
+    }
+    return declarationsPropertyAssignment;
+}
+function getNgModuleDecorator(file, moduleFilePath) {
+    const ngModuleDecorators = (0, ast_utils_1.getDecoratorMetadata)(file, 'NgModule', '@angular/core');
+    if (ngModuleDecorators.length === 0) {
+        throw new Error(`No @NgModule decorator in ${moduleFilePath}.`);
+    }
+    return ngModuleDecorators[0];
+}

package/src/generators/utils/storybook-ast/storybook-inputs.d.ts

@@ -0,0 +1,12 @@
+import type { Tree } from '@nx/devkit';
+import type { PropertyDeclaration } from 'typescript';
+export type ArgType = 'text' | 'boolean' | 'number' | 'select';
+export interface InputDescriptor {
+    name: string;
+    type: ArgType;
+    defaultValue?: string;
+}
+export declare function getInputPropertyDeclarations(tree: Tree, path: string): PropertyDeclaration[];
+export declare function getComponentProps(tree: Tree, componentPath: string, getArgsDefaultValueFn?: (property: PropertyDeclaration) => string | undefined, useDecoratorName?: boolean): InputDescriptor[];
+export declare function getArgType(property: PropertyDeclaration): ArgType;
+export declare function getArgsDefaultValue(property: PropertyDeclaration): string;

package/src/generators/utils/storybook-ast/storybook-inputs.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArgsDefaultValue = exports.getArgType = exports.getComponentProps = exports.getInputPropertyDeclarations = void 0;
+const js_1 = require("@nx/js");
+const ast_utils_1 = require("../../../utils/nx-devkit/ast-utils");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+let tsModule;
+function getInputPropertyDeclarations(tree, path) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const file = (0, ast_utils_1.getTsSourceFile)(tree, path);
+    const decorators = (0, js_1.getSourceNodes)(file).filter((node) => node.kind === tsModule.SyntaxKind.Decorator);
+    return decorators
+        .filter((decorator) => (0, js_1.findNodes)(decorator, tsModule.SyntaxKind.Identifier).some((node) => node.getText() === 'Input'))
+        .map((node) => node.parent);
+}
+exports.getInputPropertyDeclarations = getInputPropertyDeclarations;
+function getComponentProps(tree, componentPath, getArgsDefaultValueFn = getArgsDefaultValue, useDecoratorName = true) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const props = getInputPropertyDeclarations(tree, componentPath).map((node) => {
+        const decoratorContent = (0, js_1.findNodes)((0, js_1.findNodes)(node, tsModule.SyntaxKind.Decorator).find((n) => n.getText().startsWith('@Input')), tsModule.SyntaxKind.StringLiteral);
+        const name = useDecoratorName && decoratorContent.length
+            ? !decoratorContent[0].getText().includes('.')
+                ? decoratorContent[0].getText().slice(1, -1)
+                : node.name.getText()
+            : node.name.getText();
+        const type = getArgType(node);
+        const defaultValue = getArgsDefaultValueFn(node);
+        return {
+            name,
+            type,
+            defaultValue,
+        };
+    });
+    return props;
+}
+exports.getComponentProps = getComponentProps;
+function getArgType(property) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    if (property.type) {
+        const typeName = property.type.getText();
+        const typeNameToArgType = {
+            string: 'text',
+            number: 'number',
+            boolean: 'boolean',
+        };
+        return typeNameToArgType[typeName] || 'text';
+    }
+    if (property.initializer) {
+        const initializerKindToArgType = {
+            [tsModule.SyntaxKind.StringLiteral]: 'text',
+            [tsModule.SyntaxKind.NumericLiteral]: 'number',
+            [tsModule.SyntaxKind.TrueKeyword]: 'boolean',
+            [tsModule.SyntaxKind.FalseKeyword]: 'boolean',
+        };
+        return initializerKindToArgType[property.initializer.kind] || 'text';
+    }
+    return 'text';
+}
+exports.getArgType = getArgType;
+function getArgsDefaultValue(property) {
+    const typeNameToDefault = {
+        string: "''",
+        number: '0',
+        boolean: 'false',
+    };
+    return property.initializer
+        ? property.initializer.getText()
+        : property.type
+            ? typeNameToDefault[property.type.getText()]
+            : "''";
+}
+exports.getArgsDefaultValue = getArgsDefaultValue;

package/src/generators/utils/storybook-ast/tree-utilities.d.ts

@@ -0,0 +1,2 @@
+import type { Tree } from '@nx/devkit';
+export declare function getAllFilesRecursivelyFromDir(tree: Tree, dir: string): string[];

package/src/generators/utils/storybook-ast/tree-utilities.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllFilesRecursivelyFromDir = void 0;
+const devkit_1 = require("@nx/devkit");
+const ignore_1 = require("ignore");
+function getAllFilesRecursivelyFromDir(tree, dir) {
+    if (isPathIgnored(tree, dir)) {
+        return [];
+    }
+    const files = [];
+    const children = tree.children(dir);
+    children.forEach((child) => {
+        const childPath = (0, devkit_1.joinPathFragments)(dir, child);
+        if (tree.isFile(childPath)) {
+            files.push(childPath);
+        }
+        else {
+            files.push(...getAllFilesRecursivelyFromDir(tree, childPath));
+        }
+    });
+    return files;
+}
+exports.getAllFilesRecursivelyFromDir = getAllFilesRecursivelyFromDir;
+function isPathIgnored(tree, path) {
+    let ig;
+    if (tree.exists('.gitignore')) {
+        ig = (0, ignore_1.default)();
+        ig.add(tree.read('.gitignore', 'utf-8'));
+    }
+    return path !== '' && ig?.ignores(path);
+}

package/src/generators/utils/testing.d.ts

@@ -0,0 +1,10 @@
+import type { Tree } from '@nx/devkit';
+import type { Schema as ApplicationOptions } from '../application/schema';
+import type { Schema as HostOptions } from '../host/schema';
+import type { Schema as LibraryOptions } from '../library/schema';
+import type { Schema as RemoteOptions } from '../remote/schema';
+export declare function generateTestApplication(tree: Tree, options: ApplicationOptions): Promise<void>;
+export declare function generateTestHostApplication(tree: Tree, options: HostOptions): Promise<void>;
+export declare function generateTestRemoteApplication(tree: Tree, options: RemoteOptions): Promise<void>;
+export declare function generateTestLibrary(tree: Tree, options: LibraryOptions): Promise<void>;
+export declare function createStorybookTestWorkspaceForLib(libName: string): Promise<Tree>;