@siemens/element-ng 48.2.0-rc.1 → 48.3.0

package/schematics/migrations/data/component-names.js

@@ -0,0 +1,78 @@
+export const COMPONENT_NAMES_MIGRATION = [
+    // Icon current to legacy
+    {
+        module: /@(siemens|simpl)\/element-ng(\/icon)?/,
+        symbolRenamings: [
+            {
+                replace: 'SiIconComponent',
+                replaceWith: 'SiIconLegacyComponent'
+            }
+        ]
+    },
+    // Icon next to current
+    {
+        module: /@(siemens|simpl)\/element-ng(\/icon-next)?/,
+        symbolRenamings: [
+            {
+                replace: 'SiIconNextComponent',
+                replaceWith: 'SiIconComponent'
+            }
+        ]
+    },
+    // Tabs current to legacy
+    {
+        module: /@(siemens|simpl)\/element-ng(\/tabs)?/,
+        symbolRenamings: [
+            {
+                replace: 'SiTabComponent',
+                replaceWith: 'SiTabLegacyComponent'
+            },
+            {
+                replace: 'SiTabsetComponent',
+                replaceWith: 'SiTabsetLegacyComponent'
+            },
+            {
+                replace: 'SiTabsModule',
+                replaceWith: 'SiTabsLegacyModule'
+            }
+        ],
+        toModule: '@siemens/element-ng/tabs-legacy'
+    },
+    // Tabs next to current
+    {
+        module: /@(siemens|simpl)\/element-ng(\/tabs-next)?/,
+        symbolRenamings: [
+            {
+                replace: 'SiTabNextComponent',
+                replaceWith: 'SiTabComponent'
+            },
+            {
+                replace: 'SiTabsetNextComponent',
+                replaceWith: 'SiTabsetComponent'
+            },
+            {
+                replace: 'SiTabsNextModule',
+                replaceWith: 'SiTabsModule'
+            }
+        ],
+        toModule: '@siemens/element-ng/tabs'
+    },
+    // Popover current to legacy
+    {
+        module: /@(siemens|simpl)\/element-ng(\/popover)?/,
+        symbolRenamings: [
+            { replace: 'SiPopoverDirective', replaceWith: 'SiPopoverLegacyDirective' },
+            { replace: 'SiPopoverModule', replaceWith: 'SiPopoverLegacyModule' }
+        ],
+        toModule: '@siemens/element-ng/popover-legacy'
+    },
+    // Popover next to current
+    {
+        module: /@(siemens|simpl)\/element-ng(\/popover-next)?/,
+        symbolRenamings: [
+            { replace: 'SiPopoverNextDirective', replaceWith: 'SiPopoverDirective' },
+            { replace: 'SiPopoverNextModule', replaceWith: 'SiPopoverModule' }
+        ],
+        toModule: '@siemens/element-ng/popover'
+    }
+];

package/schematics/migrations/data/element-selectors.js

@@ -0,0 +1,10 @@
+export const ELEMENT_SELECTORS_MIGRATION = [
+    // current to legacy
+    { replace: 'si-icon', replaceWith: 'si-icon-legacy' },
+    { replace: 'si-tabset', replaceWith: 'si-tabset-legacy' },
+    { replace: 'si-tab', replaceWith: 'si-tab-legacy' },
+    // next to current
+    { replace: 'si-icon-next', replaceWith: 'si-icon' },
+    { replace: 'si-tabset-next', replaceWith: 'si-tabset' },
+    { replace: 'si-tab-next', replaceWith: 'si-tab' }
+];

package/schematics/migrations/data/index.js

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Siemens 2016 - 2025
+ * SPDX-License-Identifier: MIT
+ */
+import { ATTRIBUTE_SELECTORS_MIGRATION } from './attribute-selectors.js';
+import { COMPONENT_NAMES_MIGRATION } from './component-names.js';
+import { ELEMENT_SELECTORS_MIGRATION } from './element-selectors.js';
+import { OUTPUT_NAMES_MIGRATION } from './output-names.js';
+import { SYMBOL_REMOVALS_MIGRATION } from './symbol-removals.js';
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+export const getElementMigrationData = () => ({
+    attributeSelectorChanges: ATTRIBUTE_SELECTORS_MIGRATION,
+    componentNameChanges: COMPONENT_NAMES_MIGRATION,
+    elementSelectorChanges: ELEMENT_SELECTORS_MIGRATION,
+    symbolRemovalChanges: SYMBOL_REMOVALS_MIGRATION,
+    outputNameChanges: OUTPUT_NAMES_MIGRATION
+});

package/schematics/migrations/data/output-names.js

@@ -0,0 +1,8 @@
+export const OUTPUT_NAMES_MIGRATION = [
+    {
+        module: /@(siemens|simpl)\/element-ng(\/accordion)?/,
+        elementSelector: 'si-collapsible-panel',
+        componentOrModuleName: ['SiCollapsiblePanelComponent', 'SiAccordionModule'],
+        apiMappings: [{ replace: '(toggle)', replaceWith: '(panelToggle)' }]
+    }
+];

package/schematics/migrations/data/symbol-removals.js

@@ -0,0 +1,58 @@
+export const SYMBOL_REMOVALS_MIGRATION = [
+    {
+        module: /@(siemens|simpl)\/element-ng(\/accordion)?/,
+        elementSelector: 'si-accordion',
+        componentOrModuleName: ['SiAccordionComponent', 'SiAccordionModule'],
+        names: ['colorVariant']
+    },
+    {
+        module: /@(siemens|simpl)\/element-ng(\/datepicker)?/,
+        elementSelector: 'input',
+        attributeSelector: 'siDateInput',
+        componentOrModuleName: ['SiDateInputDirective', 'SiDatepickerModule'],
+        names: ['dateInputDebounceTime']
+    },
+    {
+        module: /@(siemens|simpl)\/element-ng(\/datepicker)?/,
+        elementSelector: 'input',
+        attributeSelector: 'siDatepicker',
+        componentOrModuleName: ['SiDateInputDirective', 'SiDatepickerModule'],
+        names: ['triggeringInput']
+    },
+    {
+        module: /@(siemens|simpl)\/element-ng(\/datepicker)?/,
+        elementSelector: 'si-date-range',
+        componentOrModuleName: ['SiDateRangeComponent', 'SiDatepickerModule'],
+        names: ['debounceTime']
+    },
+    {
+        module: /@(siemens|simpl)\/element-ng(\/filtered-search)?/,
+        elementSelector: 'si-filtered-search',
+        componentOrModuleName: ['SiFilteredSearchComponent', 'SiFilteredSearchModule'],
+        names: ['showIcon', 'noMatchingCriteriaText']
+    },
+    {
+        module: /@(siemens|simpl)\/element-ng(\/form)?/,
+        elementSelector: 'si-form-item',
+        componentOrModuleName: ['SiFormItemComponent', 'SiFormModule'],
+        names: ['inputId', 'readonly']
+    },
+    {
+        module: /@(siemens|simpl)\/element-ng(\/navbar-vertical)?/,
+        elementSelector: 'si-navbar-vertical',
+        componentOrModuleName: ['SiNavbarVerticalComponent', 'SiNavbarVerticalModule'],
+        names: ['autoCollapseDelay']
+    },
+    {
+        module: /@(siemens|simpl)\/element-ng(\/split)?/,
+        elementSelector: 'si-split-part',
+        componentOrModuleName: ['SiSplitPartComponent', 'SiSplitModule'],
+        names: ['headerStatusColor', 'headerStatusIconClass']
+    },
+    {
+        module: /@(siemens|simpl)\/element-ng(\/navbar-vertical)?/,
+        elementSelector: 'si-tree-view',
+        componentOrModuleName: ['SiTreeViewComponent', 'SiTreeViewModule'],
+        names: ['disableFilledIcons', 'trackByFunction']
+    }
+];

package/schematics/migrations/element-migration/element-migration.js

@@ -0,0 +1,101 @@
+/**
+ * Copyright (c) Siemens 2016 - 2025
+ * SPDX-License-Identifier: MIT
+ */
+import * as ts from 'typescript';
+import { EmitHint } from 'typescript';
+import { discoverSourceFiles, getImportSpecifiers, renameApi, renameAttribute, renameElementTag, renameIdentifier, removeSymbol } from '../../utils/index.js';
+import { getElementMigrationData } from '../data/index.js';
+export const elementMigrationRule = (options) => {
+    return async (tree, context) => {
+        const tsSourceFiles = await discoverSourceFiles(tree, context, options.path);
+        const migrationData = getElementMigrationData();
+        for (const filePath of tsSourceFiles) {
+            const content = tree.read(filePath);
+            if (!content) {
+                continue;
+            }
+            const sourceFile = ts.createSourceFile(filePath, content.toString(), ts.ScriptTarget.Latest, true);
+            let recorder = undefined;
+            let printer = undefined;
+            // Remove the ifs when it grows a bit more and split into multiple functions
+            if (migrationData.componentNameChanges) {
+                const changeInstructions = renameIdentifier({
+                    sourceFile,
+                    renamingInstructions: migrationData.componentNameChanges
+                });
+                for (const changeInstruction of changeInstructions) {
+                    recorder ??= tree.beginUpdate(filePath);
+                    printer ??= ts.createPrinter();
+                    recorder.remove(changeInstruction.start, changeInstruction.width);
+                    recorder.insertLeft(changeInstruction.start, printer.printNode(EmitHint.Unspecified, changeInstruction.newNode, sourceFile));
+                }
+            }
+            if (migrationData.attributeSelectorChanges) {
+                recorder ??= tree.beginUpdate(filePath);
+                for (const change of migrationData.attributeSelectorChanges) {
+                    renameAttribute({
+                        tree,
+                        recorder,
+                        sourceFile,
+                        filePath,
+                        fromName: change.replace,
+                        toName: change.replaceWith
+                    });
+                }
+            }
+            if (migrationData.elementSelectorChanges) {
+                recorder ??= tree.beginUpdate(filePath);
+                for (const change of migrationData.elementSelectorChanges) {
+                    renameElementTag({
+                        tree,
+                        recorder,
+                        sourceFile,
+                        filePath,
+                        fromName: change.replace,
+                        toName: change.replaceWith
+                    });
+                }
+            }
+            if (migrationData.outputNameChanges) {
+                recorder ??= tree.beginUpdate(filePath);
+                for (const change of migrationData.outputNameChanges) {
+                    const importSpecifiers = getImportSpecifiers(sourceFile, change.module, change.componentOrModuleName);
+                    if (!importSpecifiers?.length) {
+                        continue;
+                    }
+                    renameApi({
+                        tree,
+                        recorder,
+                        sourceFile,
+                        filePath,
+                        elementName: change.elementSelector,
+                        apis: change.apiMappings
+                    });
+                }
+            }
+            if (migrationData.symbolRemovalChanges) {
+                recorder ??= tree.beginUpdate(filePath);
+                for (const change of migrationData.symbolRemovalChanges) {
+                    const importSpecifiers = getImportSpecifiers(sourceFile, change.module, change.componentOrModuleName);
+                    if (!importSpecifiers?.length) {
+                        continue;
+                    }
+                    removeSymbol({
+                        tree,
+                        recorder,
+                        sourceFile,
+                        filePath,
+                        elementName: change.elementSelector,
+                        attributeSelector: change.attributeSelector,
+                        names: change.names
+                    });
+                }
+            }
+            if (recorder) {
+                tree.commitUpdate(recorder);
+            }
+        }
+        return tree;
+    };
+};

package/schematics/migrations/element-migration/index.js

@@ -0,0 +1,5 @@
+/**
+ * Copyright (c) Siemens 2016 - 2025
+ * SPDX-License-Identifier: MIT
+ */
+export * from './element-migration.js';

package/schematics/migrations/index.js

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) Siemens 2016 - 2025
+ * SPDX-License-Identifier: MIT
+ */
+import { chain } from '@angular-devkit/schematics';
+import { actionModalMigrationRule } from './action-modal-migration/index.js';
+import { elementMigrationRule } from './element-migration/index.js';
+import { wizardMigrationRule } from './wizard-migration/index.js';
+export const v47to48Migration = (options) => {
+    return (tree, context) => {
+        context.logger.info('🚀 Starting migration from v47 to v48...');
+        return chain([
+            actionModalMigrationRule(options),
+            elementMigrationRule(options),
+            wizardMigrationRule(options)
+        ])(tree, context);
+    };
+};

package/schematics/migrations/schema.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "v47to48MigrationSchema",
+  "title": "Siemens Element v47 to v48 migration",
+  "type": "object",
+  "properties": {
+    "path": {
+      "type": "string",
+      "description": "Path to the directory where the migration should be applied.",
+      "x-prompt": "Which directory do you want to migrate?",
+      "format": "path",
+      "default": "/"
+    }
+  },
+  "required": []
+}

package/schematics/migrations/wizard-migration/index.js

@@ -0,0 +1,88 @@
+/**
+ * Copyright (c) Siemens 2016 - 2025
+ * SPDX-License-Identifier: MIT
+ */
+import { join, dirname } from 'path';
+import * as ts from 'typescript';
+import { discoverSourceFiles, findElement, getImportSpecifiers, getInlineTemplates, getTemplateUrl } from '../../utils/index.js';
+export const wizardMigrationRule = (options) => {
+    return async (tree, context) => {
+        context.logger.info('🔄 Migrating wizard api...');
+        const tsSourceFiles = await discoverSourceFiles(tree, context, options.path);
+        for (const filePath of tsSourceFiles) {
+            const content = tree.read(filePath);
+            if (!content) {
+                continue;
+            }
+            const sourceFile = ts.createSourceFile(filePath, content.toString(), ts.ScriptTarget.Latest, true);
+            const modulePathToMatch = /@(siemens|simpl)\/element-ng(\/wizard)?/;
+            const wizardImports = getImportSpecifiers(sourceFile, modulePathToMatch, [
+                'SiWizardComponent',
+                'SiWizardModule'
+            ]);
+            if (!wizardImports?.length) {
+                continue;
+            }
+            const recorder = tree.beginUpdate(filePath);
+            renameApi({
+                tree,
+                filePath,
+                sourceFile,
+                recorder,
+                elementName: 'si-wizard'
+            });
+            if (recorder) {
+                tree.commitUpdate(recorder);
+            }
+        }
+    };
+};
+const renameApi = ({ tree, filePath, sourceFile, recorder, elementName }) => {
+    getInlineTemplates(sourceFile).forEach(template => addOrRemoveInlineNavigationAttribute({
+        template: template.text,
+        offset: template.getStart() + 1,
+        elementName,
+        recorder
+    }));
+    getTemplateUrl(sourceFile).forEach(templateUrl => {
+        const templatePath = join(dirname(filePath), templateUrl);
+        const templateContent = tree.read(templatePath).toString('utf-8');
+        const templateRecorder = tree.beginUpdate(templatePath);
+        addOrRemoveInlineNavigationAttribute({
+            template: templateContent,
+            offset: 0,
+            elementName,
+            recorder: templateRecorder
+        });
+        tree.commitUpdate(templateRecorder);
+    });
+};
+/**
+ * Migrates the inlineNavigation attribute on wizard elements.
+ * - Adds `inlineNavigation` when not present (new default: true)
+ * - Removes `[inlineNavigation]="false"` (false is now the default)
+ * - Keeps `[inlineNavigation]="true"` and dynamic bindings unchanged
+ */
+const addOrRemoveInlineNavigationAttribute = ({ template, offset, recorder, elementName }) => {
+    const elements = findElement(template, element => element.name === elementName);
+    for (const element of elements) {
+        const inlineNavigationAttr = element.attrs.find(attr => attr.name === '[inlineNavigation]' || attr.name === 'inlineNavigation');
+        if (!inlineNavigationAttr) {
+            // No attribute exists → Add default inlineNavigation
+            const insertPosition = element.startSourceSpan.end.offset + offset - 1;
+            recorder.insertLeft(insertPosition, ' inlineNavigation');
+        }
+        else if ((inlineNavigationAttr.name === '[inlineNavigation]' ||
+            inlineNavigationAttr.name === 'inlineNavigation') &&
+            inlineNavigationAttr.value === 'false') {
+            const { start, end } = inlineNavigationAttr.sourceSpan;
+            const length = end.offset - start.offset;
+            recorder.remove(start.offset + offset, length);
+            // Also remove extra whitespace if present
+            const nextChar = template.charAt(end.offset);
+            if (nextChar === ' ') {
+                recorder.remove(end.offset + offset, 1);
+            }
+        }
+    }
+};

package/schematics/scss-import-to-siemens-migration/index.js

@@ -26,10 +26,10 @@ export const scssImportMigration = (_options) => {
  * ```
  */
 export const scssMigrationRule = (_options) => {
-    return (tree, context) => {
+    return async (tree, context) => {
         const rules = [];
         context.logger.info('🎨 Migrating SCSS styles...');
-        const globalStyles = getGlobalStyles(tree);
+        const globalStyles = await getGlobalStyles(tree);
         for (const style of globalStyles) {
             if (style.endsWith('.scss') || style.endsWith('.sass')) {
                 const content = tree.readText(style);
@@ -51,7 +51,7 @@ export const scssMigrationRule = (_options) => {
                 }
             }
         }
-        const scssFiles = discoverSourceFiles(tree, context, _options.path, '.scss');
+        const scssFiles = await discoverSourceFiles(tree, context, _options.path, '.scss');
         for (const filePath of scssFiles) {
             const content = tree.readText(filePath);
             if (content.includes(STYLE_REPLACEMENTS[0].replace) ||

package/schematics/simpl-siemens-migration/index.js

@@ -10,7 +10,8 @@ export const simplSiemensMigration = (_options) => {
         context.logger.info('🚀 Starting Simpl to Siemens migration...');
         const chainedRules = chain([
             schematic('migrate-ts-imports-to-siemens', _options),
-            schematic('migrate-scss-imports-to-siemens', _options)
+            schematic('migrate-scss-imports-to-siemens', _options),
+            schematic('migrate-v47-to-v48', _options)
         ]);
         return chainedRules(tree, context);
     };

package/schematics/ts-import-to-siemens-migration/index.js

@@ -27,10 +27,10 @@ export const tsImportMigration = (_options) => {
  * ```
  */
 export const tsImportMigrationRule = (_options) => {
-    return (tree, context) => {
+    return async (tree, context) => {
         const rules = [];
         context.logger.info('📦 Migrating TypeScript imports...');
-        const sourceFiles = discoverSourceFiles(tree, context, _options.path);
+        const sourceFiles = await discoverSourceFiles(tree, context, _options.path);
         for (const filePath of sourceFiles) {
             const migrations = collectMigrationImports(filePath, tree, context);
             const { imports, toRemoveImports } = migrations;

package/schematics/utils/html-utils.js

@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) Siemens 2016 - 2025
+ * SPDX-License-Identifier: MIT
+ */
+import { HtmlParser, RecursiveVisitor, visitAll } from '@angular/compiler';
+export const findElement = (template, filter) => {
+    const { rootNodes, errors } = parseTemplate(template);
+    // Only evaluate templates without parse errors.
+    if (!errors.length) {
+        const visitor = new ElementCollector(filter);
+        visitAll(visitor, rootNodes);
+        return visitor.matches;
+    }
+    return [];
+};
+export const findAttribute = (template, filter) => {
+    const { rootNodes, errors } = parseTemplate(template);
+    // Only evaluate templates without parse errors.
+    if (!errors.length) {
+        const visitor = new AttributeCollector(filter);
+        visitAll(visitor, rootNodes);
+        return visitor.matches;
+    }
+    return [];
+};
+const parseTemplate = (template) => {
+    return new HtmlParser().parse(template, '', {
+        // Allows for ICUs to be parsed.
+        tokenizeExpansionForms: true,
+        // Explicitly disable blocks so that their characters are treated as plain text.
+        tokenizeBlocks: true,
+        preserveLineEndings: true
+    });
+};
+class ElementCollector extends RecursiveVisitor {
+    filter;
+    /**
+     * All elements which match the filter
+     *
+     * @defaultValue []
+     */
+    matches = [];
+    constructor(filter) {
+        super();
+        this.filter = filter;
+    }
+    visitElement(ast, context) {
+        if (this.filter(ast)) {
+            this.matches.push(ast);
+        }
+        super.visitElement(ast, context);
+    }
+}
+class AttributeCollector extends RecursiveVisitor {
+    filter;
+    /**
+     * All attributes which match the filter
+     *
+     * @defaultValue []
+     */
+    matches = [];
+    constructor(filter) {
+        super();
+        this.filter = filter;
+    }
+    visitAttribute(ast, context) {
+        if (this.filter(ast)) {
+            this.matches.push(ast);
+        }
+        super.visitAttribute(ast, context);
+    }
+}

package/schematics/utils/index.js

@@ -2,7 +2,9 @@
  * Copyright (c) Siemens 2016 - 2025
  * SPDX-License-Identifier: MIT
  */
+export * from './html-utils.js';
 export * from './project-utils.js';
-export * from './ts-utils.js';
-export * from './testing.js';
 export * from './schematics-file-system.js';
+export * from './template-utils.js';
+export * from './testing.js';
+export * from './ts-utils.js';

package/schematics/utils/project-utils.js

@@ -4,44 +4,46 @@
  */
 import { normalize } from '@angular-devkit/core';
 import { SchematicsException } from '@angular-devkit/schematics';
+import { allTargetOptions, allWorkspaceTargets, getWorkspace } from '@schematics/angular/utility/workspace';
 import { dirname, isAbsolute, resolve } from 'path';
 import { parseTsconfigFile } from './ts-utils.js';
-export const getGlobalStyles = (tree) => {
+export const getGlobalStyles = async (tree) => {
     const globalStyles = new Set();
-    for (const target of getTargets(getWorkspace(tree))) {
-        if (target.options?.styles && Array.isArray(target.options.styles)) {
-            target.options.styles.forEach((style) => {
-                if (typeof style === 'string') {
-                    globalStyles.add(normalize(style));
+    for (const [name, target] of allWorkspaceTargets(await getWorkspace(tree))) {
+        if (['build', 'test'].includes(name)) {
+            for (const [, opt] of allTargetOptions(target)) {
+                if (opt.styles && Array.isArray(opt.styles)) {
+                    opt.styles.forEach((style) => {
+                        if (typeof style === 'string') {
+                            globalStyles.add(normalize(style));
+                        }
+                    });
                 }
-            });
+            }
         }
     }
     return [...globalStyles];
 };
-export const getWorkspace = (tree) => {
-    const workspace = tree.read('/angular.json');
-    if (!workspace) {
-        throw new SchematicsException('Could not find angular.json');
-    }
-    return JSON.parse(workspace.toString());
-};
-export const getTsConfigPaths = (tree) => {
+export const getTsConfigPaths = async (tree) => {
     const buildPaths = new Set();
-    for (const target of getTargets(getWorkspace(tree))) {
-        if (target.options?.tsConfig && typeof target.options.tsConfig === 'string') {
-            const tsConfig = target.options.tsConfig;
-            if (tree.exists(tsConfig)) {
-                buildPaths.add(normalize(tsConfig));
+    for (const [name, target] of allWorkspaceTargets(await getWorkspace(tree))) {
+        if (['build', 'test'].includes(name)) {
+            for (const [, opt] of allTargetOptions(target)) {
+                if (typeof opt?.tsConfig === 'string') {
+                    const tsConfig = opt.tsConfig;
+                    if (tree.exists(tsConfig)) {
+                        buildPaths.add(normalize(tsConfig));
+                    }
+                }
             }
         }
     }
     return [...buildPaths];
 };
-export const discoverSourceFiles = (tree, context, projectPath, extension = '.ts') => {
+export const discoverSourceFiles = async (tree, context, projectPath, extension = '.ts') => {
     const basePath = normalize(process.cwd());
     // Wrap the tree to force full paths since parsing the typescript config requires full paths.
-    const tsConfigs = getTsConfigPaths(tree);
+    const tsConfigs = await getTsConfigPaths(tree);
     if (!tsConfigs.length) {
         throw new SchematicsException('Could not find any tsconfig file. Cannot run the migration.');
     }
@@ -60,16 +62,3 @@ export const discoverSourceFiles = (tree, context, projectPath, extension = '.ts
     }
     return Array.from(new Set(sourceFiles)).map(p => p.substring(basePath.length + 1));
 };
-function* getTargets(workspace, targetNames = ['build', 'test']) {
-    for (const [, projectRaw] of Object.entries(workspace.projects)) {
-        const project = projectRaw;
-        if (!project.architect) {
-            continue;
-        }
-        for (const [name, target] of Object.entries(project.architect)) {
-            if (targetNames.includes(name) && target) {
-                yield target;
-            }
-        }
-    }
-}