@siemens/element-ng 51.2.0 → 51.3.0

package/schematics/migrations/utilities/symbol-renaming.migration.js

@@ -4,16 +4,18 @@
  */
 import * as ts from 'typescript';
 import { EmitHint } from 'typescript';
-import { findImportSpecifier } from '../../utils/index.js';
+import { findImportSpecifier, getImportSpecifiers } from '../../utils/index.js';
+import { removeImportSpecifiers } from './import-removal.js';
 export const applySymbolRenamingMigration = (context, changes) => {
     const { discoveredSourceFile, recorder } = context;
     if (!changes?.length) {
         return;
     }
-    const { sourceFile } = discoveredSourceFile;
+    const { sourceFile, typeChecker } = discoveredSourceFile;
     const changeInstructions = [
         ...renameIdentifier({
             sourceFile,
+            typeChecker,
             renamingInstructions: changes
         })
     ];
@@ -26,7 +28,7 @@ export const applySymbolRenamingMigration = (context, changes) => {
         recorder.insertLeft(changeInstruction.start, printer.printNode(EmitHint.Unspecified, changeInstruction.newNode, sourceFile));
     }
 };
-function* renameIdentifier({ sourceFile, renamingInstructions }) {
+function* renameIdentifier({ sourceFile, typeChecker, renamingInstructions }) {
     for (const node of sourceFile.statements) {
         if (!ts.isImportDeclaration(node) || !ts.isStringLiteral(node.moduleSpecifier)) {
             continue;
@@ -38,6 +40,10 @@ function* renameIdentifier({ sourceFile, renamingInstructions }) {
             if (!(node.importClause?.namedBindings && ts.isNamedImports(node.importClause.namedBindings))) {
                 continue;
             }
+            if (!renamingInstruction.toModule) {
+                yield* renameSymbolsInPlace(sourceFile, typeChecker, node, renamingInstruction);
+                continue;
+            }
             // Find all symbols from this import that need to be renamed/moved
             const symbolsToProcess = [];
             for (const { replace, replaceWith } of renamingInstruction.symbolRenamings) {
@@ -126,3 +132,84 @@ function* renameIdentifier({ sourceFile, renamingInstructions }) {
         }
     }
 }
+function* renameSymbolsInPlace(sourceFile, typeChecker, declaration, instruction) {
+    const importClause = declaration.importClause;
+    const bindings = importClause.namedBindings;
+    const replacements = new Map();
+    const references = new Map();
+    const redundantImports = [];
+    for (const specifier of bindings.elements) {
+        const importedName = specifier.propertyName ?? specifier.name;
+        const rename = instruction.symbolRenamings.find(change => change.replace === importedName.text);
+        if (!rename) {
+            continue;
+        }
+        // Aliases keep their local name and only change the imported symbol.
+        if (specifier.propertyName) {
+            replacements.set(specifier, rename.replaceWith);
+            continue;
+        }
+        const existingImport = getImportSpecifiers(sourceFile, declaration.moduleSpecifier.text, rename.replaceWith).find(candidate => {
+            const isTypeOnly = candidate.isTypeOnly || candidate.parent.parent.isTypeOnly;
+            return !isTypeOnly || specifier.isTypeOnly || importClause.isTypeOnly;
+        });
+        if (existingImport) {
+            redundantImports.push(specifier);
+        }
+        else {
+            replacements.set(specifier, rename.replaceWith);
+        }
+        const symbol = typeChecker.getSymbolAtLocation(specifier.name);
+        if (symbol) {
+            references.set(symbol, existingImport?.name.text ?? rename.replaceWith);
+        }
+    }
+    if (redundantImports.length) {
+        const edit = removeImportSpecifiers(sourceFile, declaration, redundantImports);
+        const remaining = bindings.elements.filter(specifier => !redundantImports.includes(specifier));
+        const updatedBindings = ts.factory.updateNamedImports(bindings, remaining.map(specifier => {
+            const replacement = replacements.get(specifier);
+            if (!replacement) {
+                return specifier;
+            }
+            return ts.factory.updateImportSpecifier(specifier, specifier.isTypeOnly, specifier.propertyName ? ts.factory.createIdentifier(replacement) : undefined, specifier.propertyName ? specifier.name : ts.factory.createIdentifier(replacement));
+        }));
+        yield {
+            start: edit.start,
+            width: edit.width,
+            newNode: edit.newNode
+                ? ts.factory.updateImportDeclaration(declaration, declaration.modifiers, ts.factory.updateImportClause(importClause, importClause.isTypeOnly, importClause.name, updatedBindings), declaration.moduleSpecifier, declaration.attributes)
+                : ts.factory.createIdentifier('')
+        };
+    }
+    else {
+        for (const [specifier, replacement] of replacements) {
+            const importedName = specifier.propertyName ?? specifier.name;
+            yield {
+                start: importedName.getStart(),
+                width: importedName.getWidth(),
+                newNode: ts.factory.createIdentifier(replacement)
+            };
+        }
+    }
+    const visit = function* (node) {
+        if (ts.isImportDeclaration(node)) {
+            return;
+        }
+        if (ts.isIdentifier(node)) {
+            const symbol = typeChecker.getSymbolAtLocation(node);
+            const replacement = symbol && references.get(symbol);
+            if (replacement) {
+                yield {
+                    start: node.getStart(),
+                    width: node.getWidth(),
+                    newNode: ts.factory.createIdentifier(replacement)
+                };
+            }
+        }
+        for (const child of node.getChildren()) {
+            yield* visit(child);
+        }
+    };
+    yield* visit(sourceFile);
+}

package/schematics/utils/template-edit-utils.js

@@ -33,3 +33,12 @@ export const removeAttribute = (template, attribute, offset, recorder) => {
     const removeStart = start > 0 && /\s/.test(template[start - 1] ?? '') ? start - 1 : start;
     recorder.remove(removeStart + offset, end - removeStart);
 };
+/** Removes static attributes and property/attribute bindings with the given names. */
+export const removeAttributesFromElement = (template, element, names, offset, recorder) => {
+    for (const attribute of element.attrs) {
+        const matches = names.some(name => [name, `[${name}]`, `attr.${name}`, `[attr.${name}]`].includes(attribute.name));
+        if (matches) {
+            removeAttribute(template, attribute, offset, recorder);
+        }
+    }
+};

package/types/siemens-element-ng-datepicker.d.ts

@@ -217,7 +217,7 @@ declare class SiDateInputDirective implements ControlValueAccessor, OnChanges, V
     registerOnTouched(fn: () => void): void;
     registerOnValidatorChange(fn: () => void): void;
     setDisabledState(isDisabled: boolean): void;
-    writeValue(value?: Date | string): void;
+    writeValue(value?: Date | string | null): void;
     private updateNativeValue;
     /**
      * Handles `input` events on the input element.
@@ -920,6 +920,11 @@ declare class SiTimepickerComponent implements ControlValueAccessor, Validator,
      * Holds the time as date object that is presented by this control.
      */
     private time?;
+    /**
+     * Whether `null` was emitted due to an incomplete or invalid input.
+     * The next valid time must be emitted, even if it equals the previous `time`.
+     */
+    private invalidTimeEmitted;
     private periodDefaults;
     constructor();
     writeValue(obj?: Date | string): void;

package/types/siemens-element-ng-form.d.ts

@@ -388,7 +388,7 @@ declare class SiFormFieldsetComponent {
     /** @internal */
     readonly hasOnlyRadios: _angular_core.Signal<boolean>;
     protected readonly errors: _angular_core.Signal<readonly _siemens_element_ng_form.SiFormError[]>;
-    protected readonly touched: _angular_core.Signal<boolean>;
+    protected readonly showErrors: _angular_core.Signal<boolean>;
     protected readonly isRequired: _angular_core.Signal<boolean>;
     protected readonly labelId: string;
     /** @internal */

package/types/siemens-element-ng-number-input.d.ts

@@ -26,7 +26,7 @@ declare class SiNumberInputComponent implements OnChanges, ControlValueAccessor,
      */
     readonly step: _angular_core.InputSignal<number | "any">;
     /** The value */
-    readonly value: _angular_core.InputSignal<number | undefined>;
+    readonly value: _angular_core.InputSignal<number | null | undefined>;
     /** Optional unit label */
     readonly unit: _angular_core.InputSignal<string | undefined>;
     /**
@@ -104,7 +104,7 @@ declare class SiNumberInputComponent implements OnChanges, ControlValueAccessor,
     /** @internal */
     setDisabledState(isDisabled: boolean): void;
     /** @internal */
-    writeValue(value: number | undefined): void;
+    writeValue(value: number | null | undefined): void;
     /** @internal */
     validate(control: AbstractControl): ValidationErrors | null;
     /** @internal */

package/types/siemens-element-ng-popover.d.ts

@@ -13,7 +13,7 @@ declare class SiPopoverDirective implements OnDestroy {
      */
     readonly siPopover: _angular_core.InputSignal<TranslatableString | TemplateRef<unknown> | undefined>;
     /**
-     * The placement of the popover. One of 'top', 'start', end', 'bottom'
+     * The placement of the popover. One of 'top', 'start', 'end', 'bottom'
      *
      * @defaultValue 'auto'
      */

package/types/siemens-element-ng-tree-view.d.ts

@@ -372,6 +372,7 @@ declare class SiTreeViewComponent implements OnInit, OnChanges, OnDestroy, After
      */
     private virtualRoot;
     private readonly _items;
+    protected readonly svgIcons: Record<"elementExpandAll" | "elementCollapseAll", string>;
     private updateTreeItemDefaults;
     /**
      * @internal

package/types/siemens-element-ng-typeahead.d.ts

@@ -337,6 +337,13 @@ declare class SiTypeaheadDirective implements OnChanges, OnDestroy {
     private readonly unprocessedSearch;
     constructor();
     ngOnChanges(changes: SimpleChanges<this>): void;
+    /**
+     * @internal
+     *
+     * Updates the position of the typeahead overlay when already rendered.
+     * This can be useful if the input position/dimension changed.
+     */
+    updateOverlayPosition(): void;
     protected onBlur(): void;
     protected onInput(event: Event): void;
     protected onKeydownEscape(): void;