feat(dts): type ngAcceptInputType_* with the transform's parameter type

[ashley-hunter]

Stack (4/5): #493 inputs/outputs → #494 transform validation → #495 queries: → #496 .d.ts transform types → #504 signal API import identity. This is #496.

Types static ngAcceptInputType_<input> in library .d.ts output with the transform's parameter type, as ngtsc does.

The bug

Every input with a transform was declared as

static ngAcceptInputType_count: unknown;

so a consumer's template type-checking accepted any value for it. ngtsc writes the type of the transform's first parameter, so [count]="true" against (value: string | number) => number is a type error.

The fix

The type is printed the way ngtsc prints it (directive/dts_type.rs). Every part of the type is printed from the AST, never copied from the source, so type arguments, mapped types, predicates, this parameters and members all get the same rules:

• @angular/core names become i0.Name (also through import * as ng)
• local and global names, and typeof x, are kept as written
• a qualified name whose head the file declares (NS.T, A.B.T) is written as its last part, T, like ngtsc
• TypeScript's printer output: normalised spacing, double-quoted keys and strings with non-ASCII escaped (é → \u00E9), { w } patterns, normalised numbers and bigints, and the same-line comments it keeps in front of list elements
• a transform with no parameters gets unknown

The transform's type comes from:

• a function written in place, or a same-file function or static method; an overloaded one is typed from its first declaration, the one ngtsc reads
• a TypeScript lib function (parseInt, isNaN, ...), typed with its first parameter from lib.es5.d.ts
• a member @Input overriding an inputs: entry decides the type, like the compiled inputs map

The member name is quoted only when it has a - or . (Angular's isUnsafeObjectKey) and escaped like a TypeScript string ("ngAcceptInputType_a-\"b"). Any other name is written as is, like ngtsc (ngAcceptInputType_a"b).

Deliberate differences from ngtsc:

• Another module's type (including NS.T through a named import) is unknown. ngtsc adds an import * as iN for it. These aliases are numbered per source file, which can't be merged safely into bundled declaration files, since the Vite .d.ts injector combines every module's declarations.
• An imported transform is unknown: its signature can't be read from one file.
• Comments: /** */ comments after a type or on their own line, and comments spanning lines, are dropped. ngtsc keeps them.
• Forms ngtsc can't emit: a qualified name with a global head (Intl.NumberFormat) is kept as written, where ngtsc writes NumberFormat, which doesn't resolve. An enum member type (E.A) is kept as written, where ngtsc throws. import('...') types are unknown, where ngtsc aborts the build.

Known risk: local type names are written as is, like ngtsc. But ngtsc adds these members before bundling, and the Vite plugin injects them after. So in a bundled .d.ts where the bundler renamed or dropped that local type, the name can fail to resolve or bind to a different type. Per-file .d.ts output is not affected.

This PR also emits "ng-component" as the .d.ts selector of a component without one, as ngtsc does (it was never).

An enum member reached through a namespace (NS.E.A, C.E.A) is kept as written, like E.A (ngtsc throws on these). A computed property name follows the type-name rules: another module's name makes the type unknown, and @angular/core names become i0.X.

Import-equals aliases (import A = NS, import C = NS.T, export import) are typed like their target, as ngtsc does. Aliases of other modules give unknown, aliases of @angular/core give i0.X, and aliases of globals give their target (ngtsc writes a bare name that doesn't resolve). typeof this is kept, a name in a namespace merged with an enum is shortened unless it is a real enum member, and lone surrogates in string types and keys print as "\uD800".

Import-equals aliases declared inside namespaces (NS.Alias, NS.Inner.Alias2, aliases of aliases) are typed as the declaration they resolve to, like ngtsc, with the same core, other-module and global rules as top-level aliases. A transform that's a global declared outside the file is typed unknown.

import Core = require('@angular/core') and aliases of it (top level or in a namespace) type Core.X as i0.X. ngtsc writes the bare X, which doesn't resolve; require aliases of other modules stay unknown.

A computed property name through an import-equals alias resolves like a type name: @angular/core gives i0.X, another module gives unknown, and a global gives its target (ngtsc copies these as written, and its .d.ts can't resolve them). An alias of a name the file declares stays as written, like ngtsc.

Enum members named by a string or template literal ([`A`]) are recognised, so E.A / NS.E.A stay as written instead of becoming an unresolved A. Transforms declared in namespaces are typed from their declaration, like ngtsc.

Import-equals alias chains are followed to their end (a cycle gives unknown), and a U+2028 / U+2029 line break before a union no longer crashes the .d.ts printer.

Tests

• dts_input_transform_type_test.rs (new): compares the printed type of 239 type forms with what ngtsc 22.1.7 wrote into the .d.ts for the same source. It also covers the documented differences (other-module types, comments, import() types, enum members), an overloaded static method, and member-name quoting and escaping.
• Snapshot: Angular's input transforms specs from ngtsc_spec, two directive_spec acceptance cases, and probes of the type forms, qualified names and lib functions are added to the ngtsc snapshot. The test maps ngtsc's other-module types to unknown (the documented difference) and doesn't expect a static ngAcceptInputType_* the class declares itself (TypeScript writes that, not ngtsc). The cases that need declarations from another file, and the qualified-name forms above, are skipped with that reason.
• Checked by hand (on the first commit): oxc's generated library .d.ts, injected by the Vite plugin's helper, type-checks with skipLibCheck: false. ngtsc with strictTemplates accepts a consumer with valid bindings against it, and rejects wrong ones (boolean for a string | number transform, a value outside a literal union, a missing required input).

The base branch was changed.