@siemens/element-ng 48.2.0 → 48.3.0

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/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/index.js

@@ -2,9 +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 './html-utils.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;
-            }
-        }
-    }
-}

package/schematics/utils/template-utils.js

@@ -1,7 +1,7 @@
 import { join, dirname } from 'path';
 import ts from 'typescript';
 import { findAttribute, findElement } from './html-utils.js';
-const getInlineTemplates = (source) => {
+export const getInlineTemplates = (source) => {
     const templateNodes = [];
     const componentDecoratorVisitor = (node) => {
         if (ts.isDecorator(node) &&
@@ -27,7 +27,7 @@ const getInlineTemplates = (source) => {
     source.forEachChild(componentDecoratorVisitor);
     return templateNodes;
 };
-const getTemplateUrl = (source) => {
+export const getTemplateUrl = (source) => {
     const templateUrls = [];
     const componentDecoratorVisitor = (node) => {
         if (ts.isDecorator(node) &&
@@ -68,6 +68,36 @@ const renameAttributeInTemplate = ({ template, offset, recorder, fromName, toNam
         recorder.insertLeft(el.sourceSpan.start.offset + offset, toName);
     });
 };
+const renameApiInTemplate = ({ template, offset, recorder, elementName, apis }) => {
+    findElement(template, element => element.name === elementName).forEach(el => {
+        for (const api of apis) {
+            el.attrs
+                .filter(attr => attr.name === api.replace)
+                .forEach(attr => {
+                recorder.remove(attr.sourceSpan.start.offset + offset, api.replace.length);
+                recorder.insertLeft(attr.sourceSpan.start.offset + offset, api.replaceWith);
+            });
+        }
+    });
+};
+const removeSymbols = ({ template, offset, recorder, elementName, attributeSelector, names }) => {
+    findElement(template, element => element.name === elementName).forEach(el => {
+        if (attributeSelector) {
+            const hasAttributeSelector = el.attrs.some(attr => attr.name === attributeSelector);
+            if (!hasAttributeSelector) {
+                return;
+            }
+        }
+        for (const name of names) {
+            el.attrs
+                .filter(attr => attr.name === name || attr.name === `[${name}]` || attr.name === `(${name})`)
+                .forEach(attr => {
+                const apiLength = attr.sourceSpan.toString().length;
+                recorder.remove(attr.sourceSpan.start.offset + offset, apiLength);
+            });
+        }
+    });
+};
 export const renameElementTag = ({ tree, filePath, sourceFile, recorder, fromName, toName }) => {
     getInlineTemplates(sourceFile).forEach(template => renameElementTagInTemplate({
         template: template.text,
@@ -112,3 +142,49 @@ export const renameAttribute = ({ tree, filePath, sourceFile, recorder, fromName
         tree.commitUpdate(templateRecorder);
     });
 };
+export const renameApi = ({ tree, filePath, sourceFile, recorder, elementName, apis }) => {
+    getInlineTemplates(sourceFile).forEach(template => renameApiInTemplate({
+        template: template.text,
+        offset: template.getStart() + 1,
+        elementName,
+        recorder,
+        apis
+    }));
+    getTemplateUrl(sourceFile).forEach(templateUrl => {
+        const templatePath = join(dirname(filePath), templateUrl);
+        const templateContent = tree.read(templatePath).toString('utf-8');
+        const templateRecorder = tree.beginUpdate(templatePath);
+        renameApiInTemplate({
+            template: templateContent,
+            offset: 0,
+            elementName,
+            recorder: templateRecorder,
+            apis
+        });
+        tree.commitUpdate(templateRecorder);
+    });
+};
+export const removeSymbol = ({ tree, filePath, sourceFile, recorder, elementName, attributeSelector, names }) => {
+    getInlineTemplates(sourceFile).forEach(template => removeSymbols({
+        template: template.text,
+        offset: template.getStart() + 1,
+        elementName,
+        attributeSelector,
+        recorder,
+        names
+    }));
+    getTemplateUrl(sourceFile).forEach(templateUrl => {
+        const templatePath = join(dirname(filePath), templateUrl);
+        const templateContent = tree.read(templatePath).toString('utf-8');
+        const templateRecorder = tree.beginUpdate(templatePath);
+        removeSymbols({
+            template: templateContent,
+            offset: 0,
+            elementName,
+            attributeSelector,
+            recorder: templateRecorder,
+            names
+        });
+        tree.commitUpdate(templateRecorder);
+    });
+};

package/schematics/utils/ts-utils.js

@@ -150,15 +150,15 @@ export function* renameIdentifier({ sourceFile, renamingInstructions }) {
             if (!(node.importClause?.namedBindings && ts.isNamedImports(node.importClause.namedBindings))) {
                 continue;
             }
-            for (const [index, [fromName, toName]] of renamingInstruction.symbolRenamings.entries()) {
-                const importSpecifiers = findImportSpecifier(node.importClause.namedBindings.elements, fromName);
+            for (const [index, { replace, replaceWith }] of renamingInstruction.symbolRenamings.entries()) {
+                const importSpecifiers = findImportSpecifier(node.importClause.namedBindings.elements, replace);
                 if (!importSpecifiers) {
                     continue;
                 }
                 yield {
                     start: importSpecifiers.name.getStart(),
                     width: importSpecifiers.name.getWidth(),
-                    newNode: ts.factory.createIdentifier(toName)
+                    newNode: ts.factory.createIdentifier(replaceWith)
                 };
                 if (renamingInstruction.toModule &&
                     !node.moduleSpecifier.text.endsWith('@simpl/element-ng') &&
@@ -171,11 +171,11 @@ export function* renameIdentifier({ sourceFile, renamingInstructions }) {
                     };
                 }
                 const visitor = function* (visitedNode) {
-                    if (ts.isIdentifier(visitedNode) && visitedNode.text === fromName) {
+                    if (ts.isIdentifier(visitedNode) && visitedNode.text === replace) {
                         yield {
                             start: visitedNode.getStart(),
                             width: visitedNode.getWidth(),
-                            newNode: ts.factory.createIdentifier(toName)
+                            newNode: ts.factory.createIdentifier(replaceWith)
                         };
                     }
                     else {

package/template-i18n.json

@@ -1,8 +1,10 @@
 {
+  "SI_AI_MESSAGE.SECONDARY_ACTIONS": "More actions",
   "SI_ALERT_DIALOG.OK": "OK",
   "SI_APPLICATION_HEADER.LAUNCHPAD": "Launchpad",
   "SI_APPLICATION_HEADER.TOGGLE_ACTIONS": "Toggle actions",
   "SI_APPLICATION_HEADER.TOGGLE_NAVIGATION": "Toggle navigation",
+  "SI_ATTACHMENT_LIST.REMOVE_ATTACHMENT": "Remove attachment",
   "SI_BREADCRUMB": "Breadcrumbs",
   "SI_CHANGE_PASSWORD.BACK": "Back",
   "SI_CHANGE_PASSWORD.CHANGE": "Change",
@@ -11,6 +13,12 @@
   "SI_CHANGE_PASSWORD.CONFIRM_PASSWORD": "Confirm password",
   "SI_CHANGE_PASSWORD.NEW_PASSWORD": "New password",
   "SI_CHANGE_PASSWORD.PASSWORD_POLICY": "Password policy",
+  "SI_CHAT_INPUT.ATTACH_FILE": "Attach file",
+  "SI_CHAT_INPUT.INTERRUPT": "Interrupt",
+  "SI_CHAT_INPUT.LABEL": "Chat message input",
+  "SI_CHAT_INPUT.PLACEHOLDER": "Enter a message…",
+  "SI_CHAT_INPUT.SECONDARY_ACTIONS": "More actions",
+  "SI_CHAT_INPUT.SEND": "Send",
   "SI_COLUMN_SELECTION_DIALOG.CANCEL": "Cancel",
   "SI_COLUMN_SELECTION_DIALOG.HIDDEN": "Hidden",
   "SI_COLUMN_SELECTION_DIALOG.ITEM_MOVED": "Item is now at position {{targetPosition}}",
@@ -207,6 +215,7 @@
   "SI_TREE_VIEW.COLLAPSE_ALL": "Collapse all",
   "SI_TREE_VIEW.EXPAND_ALL": "Expand all",
   "SI_TYPEAHEAD.AUTOCOMPLETE_LIST_LABEL": "Suggestions",
+  "SI_USER_MESSAGE.SECONDARY_ACTIONS": "More actions",
   "SI_WIZARD.BACK": "Back",
   "SI_WIZARD.CANCEL": "Cancel",
   "SI_WIZARD.COMPLETED": "Wizard completed!",

package/translate/index.d.ts

@@ -2,10 +2,12 @@ import { Provider } from '@angular/core';
 export * from '@siemens/element-translate-ng/translate';
 
 interface SiTranslatableKeys {
+    'SI_AI_MESSAGE.SECONDARY_ACTIONS'?: string;
     'SI_ALERT_DIALOG.OK'?: string;
     'SI_APPLICATION_HEADER.LAUNCHPAD'?: string;
     'SI_APPLICATION_HEADER.TOGGLE_ACTIONS'?: string;
     'SI_APPLICATION_HEADER.TOGGLE_NAVIGATION'?: string;
+    'SI_ATTACHMENT_LIST.REMOVE_ATTACHMENT'?: string;
     'SI_BREADCRUMB'?: string;
     'SI_CHANGE_PASSWORD.BACK'?: string;
     'SI_CHANGE_PASSWORD.CHANGE'?: string;
@@ -14,6 +16,12 @@ interface SiTranslatableKeys {
     'SI_CHANGE_PASSWORD.CONFIRM_PASSWORD'?: string;
     'SI_CHANGE_PASSWORD.NEW_PASSWORD'?: string;
     'SI_CHANGE_PASSWORD.PASSWORD_POLICY'?: string;
+    'SI_CHAT_INPUT.ATTACH_FILE'?: string;
+    'SI_CHAT_INPUT.INTERRUPT'?: string;
+    'SI_CHAT_INPUT.LABEL'?: string;
+    'SI_CHAT_INPUT.PLACEHOLDER'?: string;
+    'SI_CHAT_INPUT.SECONDARY_ACTIONS'?: string;
+    'SI_CHAT_INPUT.SEND'?: string;
     'SI_COLUMN_SELECTION_DIALOG.CANCEL'?: string;
     'SI_COLUMN_SELECTION_DIALOG.HIDDEN'?: string;
     'SI_COLUMN_SELECTION_DIALOG.ITEM_MOVED'?: string;
@@ -210,6 +218,7 @@ interface SiTranslatableKeys {
     'SI_TREE_VIEW.COLLAPSE_ALL'?: string;
     'SI_TREE_VIEW.EXPAND_ALL'?: string;
     'SI_TYPEAHEAD.AUTOCOMPLETE_LIST_LABEL'?: string;
+    'SI_USER_MESSAGE.SECONDARY_ACTIONS'?: string;
     'SI_WIZARD.BACK'?: string;
     'SI_WIZARD.CANCEL'?: string;
     'SI_WIZARD.COMPLETED'?: string;

package/tree-view/index.d.ts

@@ -98,7 +98,7 @@ declare class SiTreeViewItemComponent implements OnInit, OnDestroy, AfterViewIni
     private onScrollIntoViewByConsumer;
     private expandOnClick;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SiTreeViewItemComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiTreeViewItemComponent, "si-tree-view-item", never, {}, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SiTreeViewItemComponent, "si-tree-view-item", never, {}, {}, never, [":not(si-tree-view-item):not([dragPreview])"], true, never>;
 }
 
 /**
@@ -687,6 +687,45 @@ type TreeItemContext = {
     parent: SiTreeViewComponent;
 };
 
+/**
+ * Tree view item template directive for defining custom item templates.
+ *
+ * @deprecated Use `siTreeViewItem` instead.
+ *
+ * This directive is deprecated and will be removed in a future version.
+ *
+ * @example
+ * Migration Guide:
+ *
+ * Before (deprecated):
+ * ```html
+ * <si-tree-view>
+ *   <ng-template siTreeViewItemTemplate="root" let-item>
+ *     <div class="custom-item">Root {{ item.level }}</div>
+ *   </ng-template>
+ *   <ng-template siTreeViewItemTemplate="child" let-item>
+ *     <div class="custom-item">Child {{ item.level }}</div>
+ *   </ng-template>
+ * </si-tree-view>
+ * ```
+ *
+ * After (recommended):
+ * ```html
+ * <si-tree-view>
+ *   <ng-template siTreeViewItem let-item="treeItem">
+ *     <si-tree-view-item>
+ *      <div class="custom-item">
+ *       @if (item.level === 0) {
+ *         Root {{ item.level }}
+ *       } @else {
+ *         Child {{ item.level }}
+ *       }
+ *      </div>
+ *     </si-tree-view-item>
+ *   </ng-template>
+ * </si-tree-view>
+ * ```
+ */
 declare class SiTreeViewItemTemplateDirective {
     /** @defaultValue undefined */
     readonly name: _angular_core.InputSignal<string | undefined>;

package/schematics/migrations/to-legacy-migration/to-legacy-migration.js

@@ -1,55 +0,0 @@
-import * as ts from 'typescript';
-import { EmitHint } from 'typescript';
-import { discoverSourceFiles, renameAttribute, renameElementTag, renameIdentifier } from '../../utils/index.js';
-import { IDENTIFIER_RENAMING_INSTRUCTIONS, ELEMENT_RENAMING_INSTRUCTIONS, ATTRIBUTE_RENAMING_INSTRUCTIONS } from './to-legacy-replacement.js';
-export const toLegacyMigrationRule = (options) => {
-    return (tree, context) => {
-        context.logger.info('🔄 Running legacy migration rule...');
-        const tsSourceFiles = 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 changeInstructions = renameIdentifier({
-                sourceFile,
-                renamingInstructions: IDENTIFIER_RENAMING_INSTRUCTIONS
-            });
-            let recorder = undefined;
-            let printer = undefined;
-            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 (!recorder) {
-                continue;
-            }
-            for (const [fromName, toName] of ELEMENT_RENAMING_INSTRUCTIONS) {
-                renameElementTag({
-                    tree,
-                    recorder,
-                    sourceFile,
-                    filePath,
-                    fromName,
-                    toName
-                });
-            }
-            for (const [fromName, toName] of ATTRIBUTE_RENAMING_INSTRUCTIONS) {
-                renameAttribute({
-                    tree,
-                    recorder,
-                    sourceFile,
-                    filePath,
-                    fromName,
-                    toName
-                });
-            }
-            tree.commitUpdate(recorder);
-        }
-        context.logger.info(`✅ Legacy migration complete!`);
-        return tree;
-    };
-};

package/schematics/migrations/to-legacy-migration/to-legacy-replacement.js

@@ -1,35 +0,0 @@
-/**
- * Copyright (c) Siemens 2016 - 2025
- * SPDX-License-Identifier: MIT
- */
-export const IDENTIFIER_RENAMING_INSTRUCTIONS = [
-    {
-        module: /@(siemens|simpl)\/element-ng(\/icon)?/,
-        symbolRenamings: [['SiIconComponent', 'SiIconLegacyComponent']]
-    },
-    {
-        module: /@(siemens|simpl)\/element-ng(\/tabs)?/,
-        symbolRenamings: [
-            ['SiTabComponent', 'SiTabLegacyComponent'],
-            ['SiTabsetComponent', 'SiTabsetLegacyComponent'],
-            ['SiTabsModule', 'SiTabsLegacyModule']
-        ],
-        toModule: '@siemens/element-ng/tabs-legacy'
-    },
-    {
-        module: /@(siemens|simpl)\/element-ng(\/popover)?/,
-        symbolRenamings: [
-            ['SiPopoverDirective', 'SiPopoverLegacyDirective'],
-            ['SiPopoverModule', 'SiPopoverLegacyModule']
-        ],
-        toModule: '@siemens/element-ng/popover-legacy'
-    }
-];
-export const ELEMENT_RENAMING_INSTRUCTIONS = [
-    ['si-icon', 'si-icon-legacy'],
-    ['si-tabset', 'si-tabset-legacy'],
-    ['si-tab', 'si-tab-legacy']
-];
-export const ATTRIBUTE_RENAMING_INSTRUCTIONS = [
-    ['siPopover', 'siPopoverLegacy']
-];