Import and add module to specific module path.

This is based on the original in /src/cdk/schematics/utils/ast.ts

Differences:

• Usage of the fileSystem instead of the tree directly. This ensures reuse of the cached recorders.
• Do not commit the changes directly. This is handled by the migration.

Adds the new ngx-devtools-plugin provider pattern to TypeScript files that import from @allianz/ngx-pfe-devtools.

The migration performs the following changes:

1. Adds provideDevTools({}, withPfePlugin()) to NgModule providers array
2. Adds import { provideDevTools } from '@allianz/ngx-devtools'
3. Ensures withPfePlugin is imported from @allianz/ngx-pfe-devtools

Finds a decorator by name on any class in the source file and adds provideDevTools({}, withPfePlugin()) to its providers array. If provideDevTools already exists but does not include withPfePlugin(), adds withPfePlugin() as an argument to the existing call. Returns true if any change was made.

Gets the object literal expression from a decorator's first argument.

Point insertions are order-independent with appendLeft, so no right-to-left sort is needed.

Maps each ref-var name bound to a target element onto that element's members — <pfe-error-message #err> binds err to {hideError, message, hideClose}.

The whole node tree is scanned up front (rather than per-scope) because a ref var is visible to its siblings and their descendants, so a read can legitimately precede the declaration in document order. A name declared on both a target and a non-target element is dropped: which element a read resolves to depends on view scoping we do not model.

Angular parses =, +=, ??=, … as Binary nodes, alongside comparisons ending in =.

Rewrites signal-input member reads inside an Angular template (null when nothing changed).

hostMembers are the inputs the backing component inherits from a target and drive the implicit-receiver / this.x reads; it is empty for a plain consumer template, whose ref-var reads resolve from the template itself.

Reads on template-locals (*ngFor="let x of ...", @for, @if ... as x, @let x = ...) shadow the component member and are skipped — the template analogue of the subclass member-shadowing rule on the TypeScript side.

Only the first error of a template is reported: the later ones are usually cascade noise from the same root cause (one unescaped { yields both an "unexpected EOF" and an "invalid ICU").

Registry of class name -> the target that class DIRECTLY extends.

Maps every local name that refers to a target component onto that component. A namespace import is keyed on the qualified name (ndbx.PfeErrorMessageComponent), which is what keeps it from bleeding into a named import: an unrelated other.PfeErrorMessageComponent never matches, because only the exact <namespace>.<className> pair is registered.

Reports every re-export of a target component, so the one shape this migration knowingly cannot follow is visible instead of silent.

// local-barrel.ts
export { PfeErrorMessageComponent } from '@allianz/ngx-pfe-ndbx';
// consumer.ts — NOT migrated
import { PfeErrorMessageComponent } from './local-barrel';

collectLocalTargetReferences matches an import's module specifier against the entry point verbatim, so './local-barrel' never matches, and following the chain across N hops is a much bigger surface than the case is worth. Reporting matters because an un-unwrapped read does not fail loudly: the member is now a getter function, so it silently evaluates as always-truthy. Only the barrel is reported — the set of files importing from it is unbounded.

A name is returned exactly as written, so a qualified ns.Foo stays qualified. It must NOT be reduced to its right-most segment: other.PfeErrorMessageComponent, from an unrelated module that happens to export the same class name, would then match a PfeErrorMessageComponent imported elsewhere in the file and be wrongly rewritten.

Resolves the declaration a receiver binds to — foo.member (the identifier foo) or this.bar.member (the this.bar property access); undefined for anything more complex. Resolving via the symbol rather than the identifier text is what makes the pass scope-aware.

A plain string or no-substitution template literal (both expose getLiteralText / setLiteralValue). Substitution template literals (\...${x}...``) are skipped — an inline template that interpolates TS values cannot be rewritten as a single literal.

Maps each external template path onto the migrated members its component inherits from a target: unlike a ref-var read, such a template carries no clue in the HTML about its owner.

Resolution is deliberately shallow — only a class that directly extends an import-gated target is indexed. A deeper chain is reported rather than guessed at, because following it would mean resolving base classes across files in a virtual tree where the @allianz/* packages are typically not resolvable.

True when access is the assignment target of a destructuring pattern — [this.x] = arr or ({ a: this.x } = obj). Such an access sits (directly, or via nested patterns / a leading spread) inside an array/object literal that is the LHS of an =.

A barrel is admitted via RE_EXPORT_PATTERN because export * names no target class of its own and would otherwise be filtered out.

A file with such an inline template need not import anything from a target entry point — in an NgModule consumer the module is imported by the NgModule, not by the component using <pfe-error-message #err> — so the import-based filter above would drop it.

Normalizes a path so index keys and lookup keys compare equal.

Rewrites ref.<member> accesses where ref is a variable, parameter or property typed as a target component. Matching is resolved per access against the receiver's actual declaration in scope (via its symbol), not by identifier name — so two references that share a name but are typed differently are handled independently.

Resolves the target a declaration's explicit type annotation refers to. The annotation is decomposed structurally so any class-name constituent is considered:

• PfeErrorMessageComponent — a plain type reference
• PfeErrorMessageComponent | null | undefined — a union (each member checked)
• (PfeErrorMessageComponent | null) — parenthesized (unwrapped)
• A & PfeErrorMessageComponent — an intersection (each member checked)
• ndbx.PfeErrorMessageComponent — qualified via a namespace import

Types with no explicit annotation (inferred) cannot be matched textually and return null.

A member re-declared in the subclass shadows the base-class input — as a property, an accessor (override get message()) or a method, any of which returns something other than the base signal — so this.member must NOT be unwrapped and the name is filtered out.

Records the accesses that cannot be migrated automatically, then repeatedly unwraps the remaining reads (x -> x()), re-querying the AST after each mutation so no stale ts-morph node is touched.

Termination relies on an unwrapped access classifying as none afterwards, which is why a function-valued member is handled by marking the new call node as visited rather than by re-classifying it: this.nxNextAction() is a legitimate migration target (it must become this.nxNextAction()()), so it can never be recognised as already-migrated without looping forever.

Rewrites reads of the inputs that changed from @Input to signal input(), so every read of a migrated member gains a (). Three consumer pathways are covered:

• subclass access — this.<member> inside a class that extends a target, plus that class's own template (inline and external);
• instance access — ref.<member> where ref is a variable, parameter or property whose declared type is a target component;
• template ref-var access — {{ err.message }} where err is a reference variable bound to a target element, in any template.

tsSources must contain every .ts file in scope and htmlSources every .html file: external templates are attributed to their component in a pre-pass over the TypeScript files.

The headers of an HttpErrorResponse are stored as a map. This function converts them to an object so that JSONPath expressions can be used against them.

Helper to check the emitted values of an observable.

Checks that the expected values are emitted. Also checks that no more than the expected number of values is emitted.

Takes a path segment and extracts the query parameters from it. Returns the stripped path as well as the extracted query parameters. Paths that don't contain any query parameters will be left unchanged.

Finds a NgModule declaration within the specified TypeScript node and returns the corresponding metadata for it. This function searches breadth first because NgModule's are usually not nested within other expressions or declarations.

Whether the specified call expression is referring to a NgModule definition.

Resolves the last identifier that is part of the given expression. This helps resolving identifiers of nested property access expressions (e.g. myNamespace.core.NgModule).

Get the pfe page ID from any ActivatedRouteSnapshot. This can be from the root or anywhere lower in the tree.

Diff two values and return changes as JSONPath-addressed entries.

• added: path exists only in next
• removed: path exists only in previous
• modified: leaf value differs (including type changes)

Gets the tsconfig path from the given target within the specified project.

Resolve the workspace configuration of the specified tree gracefully.

Whether the Angular module in the given path imports the specified module class name with a forRoot call.

This is a rather basic implementation of a ngModule import removal. It collects the necessary changes and returns them. If the NgModule or the import was not found an empty changes array is returned.

It currently does not handle edge cases, like it being the only import. (Which simply leaves an empty array of imports)