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

package/src/generators/utils/add-jest.d.ts

@@ -0,0 +1,8 @@
+import { type Tree } from '@nx/devkit';
+export type AddJestOptions = {
+    name: string;
+    projectRoot: string;
+    skipPackageJson: boolean;
+    strict: boolean;
+};
+export declare function addJest(tree: Tree, options: AddJestOptions): Promise<void>;

package/src/generators/utils/add-jest.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addJest = void 0;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../utils/versions");
+const version_utils_1 = require("./version-utils");
+async function addJest(tree, options) {
+    if (!options.skipPackageJson) {
+        process.env.npm_config_legacy_peer_deps ??= 'true';
+        (0, version_utils_1.addDependenciesToPackageJsonIfDontExist)(tree, {}, { 'jest-preset-angular': versions_1.jestPresetAngularVersion });
+    }
+    const { configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/jest', versions_1.nxVersion);
+    await configurationGenerator(tree, {
+        project: options.name,
+        setupFile: 'angular',
+        supportTsx: false,
+        skipSerializers: false,
+        skipPackageJson: options.skipPackageJson,
+        skipFormat: true,
+        addPlugin: false,
+        addExplicitTargets: true,
+    });
+    const setupFile = (0, devkit_1.joinPathFragments)(options.projectRoot, 'src', 'test-setup.ts');
+    if (options.strict && tree.exists(setupFile)) {
+        const contents = tree.read(setupFile, 'utf-8');
+        tree.write(setupFile, `// @ts-expect-error https://thymikee.github.io/jest-preset-angular/docs/getting-started/test-environment
+globalThis.ngJest = {
+testEnvironmentOptions: {
+  errorOnUnknownElements: true,
+  errorOnUnknownProperties: true,
+},
+};
+${contents}`);
+    }
+}
+exports.addJest = addJest;

package/src/generators/utils/add-mf-env-to-inputs.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export declare function addMfEnvToTargetDefaultInputs(tree: Tree): void;

package/src/generators/utils/add-mf-env-to-inputs.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addMfEnvToTargetDefaultInputs = void 0;
+const devkit_1 = require("@nx/devkit");
+function addMfEnvToTargetDefaultInputs(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const webpackExecutor = '@nx/angular:webpack-browser';
+    const mfEnvVar = 'NX_MF_DEV_SERVER_STATIC_REMOTES';
+    nxJson.targetDefaults ??= {};
+    nxJson.targetDefaults[webpackExecutor] ??= {};
+    nxJson.targetDefaults[webpackExecutor].inputs ??= [];
+    let mfEnvVarExists = false;
+    for (const input of nxJson.targetDefaults[webpackExecutor].inputs) {
+        if (typeof input === 'object' && input['env'] === mfEnvVar) {
+            mfEnvVarExists = true;
+            break;
+        }
+    }
+    if (!mfEnvVarExists) {
+        nxJson.targetDefaults[webpackExecutor].inputs.push({ env: mfEnvVar });
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+}
+exports.addMfEnvToTargetDefaultInputs = addMfEnvToTargetDefaultInputs;

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

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export declare function addBuildableLibrariesPostCssDependencies(tree: Tree): void;

package/src/generators/utils/dependencies.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addBuildableLibrariesPostCssDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const version_utils_1 = require("./version-utils");
+function addBuildableLibrariesPostCssDependencies(tree) {
+    const pkgVersions = (0, version_utils_1.versions)(tree);
+    (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+        postcss: pkgVersions.postcssVersion,
+        autoprefixer: pkgVersions.autoprefixerVersion,
+        'postcss-url': pkgVersions.postcssUrlVersion,
+    });
+}
+exports.addBuildableLibrariesPostCssDependencies = addBuildableLibrariesPostCssDependencies;

package/src/generators/utils/ensure-angular-dependencies.d.ts

@@ -0,0 +1,2 @@
+import type { GeneratorCallback, Tree } from '@nx/devkit';
+export declare function ensureAngularDependencies(tree: Tree): GeneratorCallback;

package/src/generators/utils/ensure-angular-dependencies.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureAngularDependencies = void 0;
+const version_utils_1 = require("./version-utils");
+function ensureAngularDependencies(tree) {
+    const pkgVersions = (0, version_utils_1.versions)(tree);
+    const angularVersion = (0, version_utils_1.getInstalledPackageVersion)(tree, '@angular/core') ??
+        pkgVersions.angularVersion;
+    const angularDevkitVersion = (0, version_utils_1.getInstalledPackageVersion)(tree, '@angular-devkit/build-angular') ??
+        pkgVersions.angularDevkitVersion;
+    const rxjsVersion = (0, version_utils_1.getInstalledPackageVersion)(tree, 'rxjs') ?? pkgVersions.rxjsVersion;
+    const tsLibVersion = (0, version_utils_1.getInstalledPackageVersion)(tree, 'tslib') ?? pkgVersions.tsLibVersion;
+    const zoneJsVersion = (0, version_utils_1.getInstalledPackageVersion)(tree, 'zone.js') ?? pkgVersions.zoneJsVersion;
+    return (0, version_utils_1.addDependenciesToPackageJsonIfDontExist)(tree, {
+        '@angular/animations': angularVersion,
+        '@angular/common': angularVersion,
+        '@angular/compiler': angularVersion,
+        '@angular/core': angularVersion,
+        '@angular/forms': angularVersion,
+        '@angular/platform-browser': angularVersion,
+        '@angular/platform-browser-dynamic': angularVersion,
+        '@angular/router': angularVersion,
+        rxjs: rxjsVersion,
+        tslib: tsLibVersion,
+        'zone.js': zoneJsVersion,
+    }, {
+        '@angular/cli': angularDevkitVersion,
+        '@angular/compiler-cli': angularVersion,
+        '@angular/language-service': angularVersion,
+        '@angular-devkit/build-angular': angularDevkitVersion,
+        '@angular-devkit/schematics': angularDevkitVersion,
+        '@schematics/angular': angularDevkitVersion,
+    });
+}
+exports.ensureAngularDependencies = ensureAngularDependencies;

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

@@ -0,0 +1,2 @@
+import type { Tree } from '@nx/devkit';
+export declare function locateLibraryEntryPointFromDirectory(tree: Tree, directory: string, projectRoot: string, projectSourceRoot: string): string | null;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.locateLibraryEntryPointFromDirectory = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+function locateLibraryEntryPointFromDirectory(tree, directory, projectRoot, projectSourceRoot) {
+    const ngPackageJsonPath = (0, devkit_1.joinPathFragments)(directory, 'ng-package.json');
+    let entryPointFile = tree.exists(ngPackageJsonPath)
+        ? (0, devkit_1.readJson)(tree, ngPackageJsonPath).lib?.entryFile ?? 'src/public_api.ts'
+        : null;
+    if (entryPointFile) {
+        return (0, devkit_1.joinPathFragments)(directory, entryPointFile);
+    }
+    if (directory === projectRoot) {
+        const indexFile = (0, devkit_1.joinPathFragments)(projectSourceRoot, 'index.ts');
+        return tree.exists(indexFile) ? indexFile : null;
+    }
+    return locateLibraryEntryPointFromDirectory(tree, (0, path_1.dirname)(directory), projectRoot, projectSourceRoot);
+}
+exports.locateLibraryEntryPointFromDirectory = locateLibraryEntryPointFromDirectory;

package/src/generators/utils/export-scam.d.ts

@@ -0,0 +1,10 @@
+import type { Tree } from '@nx/devkit';
+export type GenerationOptions = {
+    directory: string;
+    filePath: string;
+    name: string;
+    projectName: string;
+    export?: boolean;
+    inlineScam?: boolean;
+};
+export declare function exportScam(tree: Tree, options: GenerationOptions): void;

package/src/generators/utils/export-scam.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportScam = void 0;
+const devkit_1 = require("@nx/devkit");
+const entry_point_1 = require("./entry-point");
+const path_1 = require("./path");
+function exportScam(tree, options) {
+    if (!options.export) {
+        return;
+    }
+    const { projectType, root, sourceRoot } = (0, devkit_1.readProjectConfiguration)(tree, options.projectName);
+    const projectSourceRoot = sourceRoot ?? (0, devkit_1.joinPathFragments)(root, 'src');
+    if (projectType === 'application') {
+        devkit_1.logger.warn('--export=true was ignored as the project the SCAM is being generated in is not a library.');
+        return;
+    }
+    const entryPointPath = (0, entry_point_1.locateLibraryEntryPointFromDirectory)(tree, options.directory, root, projectSourceRoot);
+    if (!entryPointPath) {
+        // Let's not error, simply warn the user
+        // It's not too much effort to manually do this
+        // It would be more frustrating to have to find the correct path and re-run the command
+        devkit_1.logger.warn(`Could not export SCAM. Unable to determine project's entry point. SCAM has still been created.`);
+        return;
+    }
+    const relativePathFromEntryPoint = (0, path_1.getRelativeImportToFile)(entryPointPath, options.filePath);
+    const entryPointContent = tree.read(entryPointPath, 'utf-8');
+    let updatedEntryPointContent = (0, devkit_1.stripIndents) `${entryPointContent}
+    export * from '${relativePathFromEntryPoint}';`;
+    if (!options.inlineScam) {
+        const moduleFilePath = (0, devkit_1.joinPathFragments)(options.directory, `${(0, devkit_1.names)(options.name).fileName}.module.ts`);
+        const relativePathFromModule = (0, path_1.getRelativeImportToFile)(entryPointPath, moduleFilePath);
+        updatedEntryPointContent = (0, devkit_1.stripIndents) `${updatedEntryPointContent}
+        export * from '${relativePathFromModule}';`;
+    }
+    tree.write(entryPointPath, updatedEntryPointContent);
+}
+exports.exportScam = exportScam;

package/src/generators/utils/find-module.d.ts

@@ -0,0 +1,4 @@
+import type { Tree } from '@nx/devkit';
+import { ngModuleDecoratorProperty } from './insert-ngmodule-import';
+export declare function findModule(tree: Tree, path: string, module?: string): string;
+export declare function addToNgModule(tree: Tree, path: string, modulePath: string, name: string, className: string, fileName: string, ngModuleProperty: ngModuleDecoratorProperty, isFlat?: boolean, isExported?: boolean): void;

package/src/generators/utils/find-module.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addToNgModule = exports.findModule = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+const js_1 = require("@nx/js");
+const insert_ngmodule_import_1 = require("./insert-ngmodule-import");
+let tsModule;
+function findModule(tree, path, module) {
+    let modulePath = '';
+    let pathToSearch = path;
+    while (pathToSearch !== '.' && pathToSearch !== '/') {
+        if (module) {
+            const pathToModule = (0, devkit_1.joinPathFragments)(pathToSearch, module);
+            if (tree.exists(pathToModule)) {
+                modulePath = pathToModule;
+                break;
+            }
+        }
+        else {
+            const potentialOptions = tree
+                .children(pathToSearch)
+                .filter((f) => f.endsWith('.module.ts'));
+            if (potentialOptions.length > 1) {
+                throw new Error(`More than one NgModule was found. Please provide the NgModule you wish to use.`);
+            }
+            else if (potentialOptions.length === 1) {
+                modulePath = (0, devkit_1.joinPathFragments)(pathToSearch, potentialOptions[0]);
+                break;
+            }
+        }
+        pathToSearch = (0, path_1.dirname)(pathToSearch);
+    }
+    if (modulePath === '') {
+        throw new Error('Could not find a declaring module file.');
+    }
+    const moduleContents = tree.read(modulePath, 'utf-8');
+    if (!moduleContents.includes('@NgModule')) {
+        throw new Error(`Declaring module file (${modulePath}) does not contain an @NgModule Declaration.`);
+    }
+    return modulePath;
+}
+exports.findModule = findModule;
+function addToNgModule(tree, path, modulePath, name, className, fileName, ngModuleProperty, 
+// TODO(leo): remove once all consumers are updated
+// // check if exported in the public api
+isFlat = true, isExported = false) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    let relativePath = `${(0, devkit_1.joinPathFragments)(path.replace((0, path_1.dirname)(modulePath), ''), !isFlat ? name : '', `${fileName}`)}`;
+    relativePath = relativePath.startsWith('/')
+        ? `.${relativePath}`
+        : `./${relativePath}`;
+    const moduleContents = tree.read(modulePath, 'utf-8');
+    const source = tsModule.createSourceFile(modulePath, moduleContents, tsModule.ScriptTarget.Latest, true);
+    (0, js_1.insertImport)(tree, source, modulePath, className, relativePath);
+    (0, insert_ngmodule_import_1.insertNgModuleProperty)(tree, modulePath, className, ngModuleProperty);
+    if (isExported) {
+        (0, insert_ngmodule_import_1.insertNgModuleProperty)(tree, modulePath, className, 'exports');
+    }
+}
+exports.addToNgModule = addToNgModule;

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

@@ -0,0 +1,2 @@
+export * from './insert-ngmodule-import';
+export * from './find-module';

package/src/generators/utils/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./insert-ngmodule-import"), exports);
+tslib_1.__exportStar(require("./find-module"), exports);

package/src/generators/utils/insert-ngmodule-import.d.ts

@@ -0,0 +1,4 @@
+import { Tree } from '@nx/devkit';
+export type ngModuleDecoratorProperty = 'imports' | 'providers' | 'declarations' | 'exports';
+export declare function insertNgModuleProperty(tree: Tree, modulePath: string, name: string, property: ngModuleDecoratorProperty): void;
+export declare function insertNgModuleImport(tree: Tree, modulePath: string, importName: string): void;

package/src/generators/utils/insert-ngmodule-import.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertNgModuleImport = exports.insertNgModuleProperty = void 0;
+const devkit_1 = require("@nx/devkit");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+let tsModule;
+function insertNgModuleProperty(tree, modulePath, name, property) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const contents = tree.read(modulePath).toString('utf-8');
+    const sourceFile = tsModule.createSourceFile(modulePath, contents, tsModule.ScriptTarget.ESNext);
+    const coreImport = findImport(sourceFile, '@angular/core');
+    if (!coreImport) {
+        throw new Error(`There are no imports from "@angular/core" in ${modulePath}.`);
+    }
+    const ngModuleNamedImport = getNamedImport(coreImport, 'NgModule');
+    const ngModuleName = ngModuleNamedImport.name.escapedText;
+    const ngModuleClassDeclaration = findDecoratedClass(sourceFile, ngModuleName);
+    const { getDecorators } = getTsEsLintTypeUtils();
+    const ngModuleDecorator = getDecorators(ngModuleClassDeclaration).find((decorator) => tsModule.isCallExpression(decorator.expression) &&
+        tsModule.isIdentifier(decorator.expression.expression) &&
+        decorator.expression.expression.escapedText === ngModuleName);
+    const ngModuleCall = ngModuleDecorator.expression;
+    if (ngModuleCall.arguments.length < 1) {
+        const newContents = (0, devkit_1.applyChangesToString)(contents, [
+            {
+                type: devkit_1.ChangeType.Insert,
+                index: ngModuleCall.getEnd() - 1,
+                text: `{ ${property}: [${name}]}`,
+            },
+        ]);
+        tree.write(modulePath, newContents);
+    }
+    else {
+        if (!tsModule.isObjectLiteralExpression(ngModuleCall.arguments[0])) {
+            throw new Error(`The NgModule options for ${ngModuleClassDeclaration.name.escapedText} in ${modulePath} is not an object literal`);
+        }
+        const ngModuleOptions = ngModuleCall
+            .arguments[0];
+        const typeProperty = findPropertyAssignment(ngModuleOptions, property);
+        if (!typeProperty) {
+            let text = `${property}: [${name}]`;
+            if (ngModuleOptions.properties.hasTrailingComma) {
+                text = `${text},`;
+            }
+            else if (ngModuleOptions.properties.length) {
+                text = `, ${text}`;
+            }
+            const newContents = (0, devkit_1.applyChangesToString)(contents, [
+                {
+                    type: devkit_1.ChangeType.Insert,
+                    index: ngModuleOptions.getEnd() - 1,
+                    text,
+                },
+            ]);
+            tree.write(modulePath, newContents);
+        }
+        else {
+            if (!tsModule.isArrayLiteralExpression(typeProperty.initializer)) {
+                throw new Error(`The NgModule ${property} for ${ngModuleClassDeclaration.name.escapedText} in ${modulePath} is not an array literal`);
+            }
+            let text;
+            if (typeProperty.initializer.elements.hasTrailingComma) {
+                text = `${name},`;
+            }
+            else if (typeProperty.initializer.elements.length) {
+                text = `, ${name}`;
+            }
+            else {
+                text = name;
+            }
+            const newContents = (0, devkit_1.applyChangesToString)(contents, [
+                {
+                    type: devkit_1.ChangeType.Insert,
+                    index: typeProperty.initializer.getEnd() - 1,
+                    text,
+                },
+            ]);
+            tree.write(modulePath, newContents);
+        }
+    }
+}
+exports.insertNgModuleProperty = insertNgModuleProperty;
+function insertNgModuleImport(tree, modulePath, importName) {
+    insertNgModuleProperty(tree, modulePath, importName, 'imports');
+}
+exports.insertNgModuleImport = insertNgModuleImport;
+function findImport(sourceFile, importPath) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const importStatements = sourceFile.statements.filter(tsModule.isImportDeclaration);
+    return importStatements.find((statement) => statement.moduleSpecifier
+        .getText(sourceFile)
+        .replace(/['"`]/g, '')
+        .trim() === importPath);
+}
+function getNamedImport(coreImport, importName) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    if (!tsModule.isNamedImports(coreImport.importClause.namedBindings)) {
+        throw new Error(`The import from ${coreImport.moduleSpecifier} does not have named imports.`);
+    }
+    return coreImport.importClause.namedBindings.elements.find((namedImport) => namedImport.propertyName
+        ? tsModule.isIdentifier(namedImport.propertyName) &&
+            namedImport.propertyName.escapedText === importName
+        : tsModule.isIdentifier(namedImport.name) &&
+            namedImport.name.escapedText === importName);
+}
+function findDecoratedClass(sourceFile, ngModuleName) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const classDeclarations = sourceFile.statements.filter(tsModule.isClassDeclaration);
+    const { getDecorators } = getTsEsLintTypeUtils();
+    return classDeclarations.find((declaration) => {
+        const decorators = getDecorators(declaration);
+        if (decorators) {
+            return decorators.some((decorator) => tsModule.isCallExpression(decorator.expression) &&
+                tsModule.isIdentifier(decorator.expression.expression) &&
+                decorator.expression.expression.escapedText === ngModuleName);
+        }
+        return undefined;
+    });
+}
+function findPropertyAssignment(ngModuleOptions, propertyName) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    return ngModuleOptions.properties.find((property) => tsModule.isPropertyAssignment(property) &&
+        tsModule.isIdentifier(property.name) &&
+        property.name.escapedText === propertyName);
+}
+let tsUtils;
+function getTsEsLintTypeUtils() {
+    return tsUtils ?? require('@typescript-eslint/type-utils');
+}

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

@@ -0,0 +1 @@
+export declare function getRelativeImportToFile(sourceFilePath: string, targetFilePath: string): string;

package/src/generators/utils/path.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelativeImportToFile = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+function getRelativeImportToFile(sourceFilePath, targetFilePath) {
+    const relativeDirToTarget = (0, path_1.relative)((0, path_1.dirname)(sourceFilePath), (0, path_1.dirname)(targetFilePath));
+    return `./${(0, devkit_1.joinPathFragments)(relativeDirToTarget, (0, path_1.basename)(targetFilePath, '.ts'))}`;
+}
+exports.getRelativeImportToFile = getRelativeImportToFile;

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

@@ -0,0 +1,2 @@
+import type { Tree } from '@nx/devkit';
+export declare function getProjectPrefix(tree: Tree, project: string): string | undefined;

package/src/generators/utils/project.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectPrefix = void 0;
+const devkit_1 = require("@nx/devkit");
+function getProjectPrefix(tree, project) {
+    return (0, devkit_1.readProjectConfiguration)(tree, project).prefix;
+}
+exports.getProjectPrefix = getProjectPrefix;

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

@@ -0,0 +1,3 @@
+import { names } from '@nx/devkit';
+export declare function buildSelector(name: string, prefix: string | undefined, projectPrefix: string | undefined, casing: keyof Pick<ReturnType<typeof names>, 'fileName' | 'propertyName'>): string;
+export declare function validateHtmlSelector(selector: string): void;

package/src/generators/utils/selector.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateHtmlSelector = exports.buildSelector = void 0;
+const devkit_1 = require("@nx/devkit");
+function buildSelector(name, prefix, projectPrefix, casing) {
+    let selector = name;
+    prefix ??= projectPrefix;
+    if (prefix) {
+        selector = `${prefix}-${selector}`;
+    }
+    return (0, devkit_1.names)(selector)[casing];
+}
+exports.buildSelector = buildSelector;
+// https://github.com/angular/angular-cli/blob/main/packages/schematics/angular/utility/validation.ts#L11-L14
+const htmlSelectorRegex = /^[a-zA-Z][.0-9a-zA-Z]*((:?-[0-9]+)*|(:?-[a-zA-Z][.0-9a-zA-Z]*(:?-[0-9]+)*)*)$/;
+function validateHtmlSelector(selector) {
+    if (selector && !htmlSelectorRegex.test(selector)) {
+        throw new Error(`The selector "${selector}" is invalid.`);
+    }
+}
+exports.validateHtmlSelector = validateHtmlSelector;

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

@@ -0,0 +1,11 @@
+import { Tree } from '@nx/devkit';
+import type { EntryPoint } from './entry-point';
+export interface ComponentInfo {
+    componentFileName: string;
+    moduleFolderPath: string;
+    name: string;
+    path: string;
+    entryPointName: string;
+}
+export declare function getComponentsInfo(tree: Tree, entryPoint: EntryPoint, moduleFilePaths: string[], projectName: string): ComponentInfo[];
+export declare function getStandaloneComponentsInfo(tree: Tree, entryPoint: EntryPoint): ComponentInfo[];