[GabeSilvaDev]

Summary

Closes #313.

A standalone component or directive listed in @Component.imports and used only inside a @defer block was compiled as an eager dependency. It stayed in ɵɵgetComponentDepsFactory, its static import stayed at the top of the file, and ɵɵdefer got no resolver, so the block did no code-splitting. Only deferredImports was lazy-loaded (#307). ngc's full compilation defers such imports implicitly (resolveDeferBlocks / registerDeferrableCandidate in the component handler.ts).

The comment left in #307 explains why OXC didn't do this: the selectors live on the imported class, in another file. CrossFileAnalyzer can now follow an import to that class, so with cross-file analysis on (resolve_imported_values, which the Vite plugin always sets) OXC does what ngc does:

import { LazyCmp } from './lazy';

@Component({
  selector: 'app-parent',
  imports: [LazyCmp],
  template: '@defer { <app-lazy/> }',
})
export class Parent {}

now compiles to

i0.ɵɵdefer(1, 0, () => [import("./lazy").then((m) => m.LazyCmp)]);
// ...
dependencies: i0.ɵɵgetComponentDepsFactory(Parent, [])

with no static import { LazyCmp }, and with ɵsetClassMetadataAsync taking LazyCmp as its callback parameter, the same output deferredImports: [LazyCmp] gives today.

Piece	Change
pipeline/selector.rs	CssSelector::matches, the matching half of Angular's SelectorMatcher: element, classes, attributes with and without a value, selector lists and :not. A :not(...)-only selector matches any element, and an empty one (trailing comma) matches nothing. OXC had the parser but no matcher.
component/cross_file_elision.rs	CrossFileAnalyzer::standalone_directive_selector follows an import, through named re-exports, to the class declaration and reads its @Component / @Directive selector. It returns None for packages, export *, a non-literal selector or standalone, a computed key in the decorator, and a class that is not standalone. A plain class X counts only when the file exports it under that name (export { X }), so a namespace member can't point the lookup at the wrong class. It reuses the source analyze_file already read and caches each result. Files read are reported as watch dependencies, like the ones resolve_imported_values reads.
component/defer_resolver.rs	implicitly_deferred_imports walks the template and builds each element's attributes the way getAttrsForDirectiveMatching does: static attributes, property and two-way bindings, outputs, and the template attributes of a structural directive. Namespace prefixes (:svg:, :xlink:) are stripped, only i18n / i18n-* are skipped, class is found in any case, and a binding replaces a static attribute of the same name. A candidate is deferred when it matches inside a @defer block's main content and nowhere else. The @placeholder / @loading / @error of a @defer nested in another block's main content count as deferred, like ngc's binder.
component/import_elision.rs	Counts the value references to each import, records the non-type specifiers of each import declaration, tracks names other emitted code still needs, and can elide an import after compilation.
component/transform.rs	The deferred entries join deferredImports, so they share its resolver and setClassMetadataAsync. They are taken out of the imports literal, and their static import is removed. The jit: true imports are kept in a pass before any class compiles, so the result doesn't depend on class order.

An import stays eager when:

• it is also matched outside a @defer block, including in @placeholder, @loading and @error, which render before the chunk loads;
• it is referenced anywhere else in the file, so the static import can't go, including by code OXC emits for another class (ctorParameters of a jit: true class, setClassMetadata constructor types);
• another non-type specifier of the same import declaration is not deferred too, as ngc's DeferredSymbolTracker.canDefer requires (an interface imported without type counts, as in ngc);
• its selector can't be read from source (packages, export *, a computed selector, import { X } from './x'; export { X } barrels, .js-style specifiers such as ./lazy.js);
• it matches nothing in the template (as in ngc);
• imports is not an array of plain identifiers (a variable or a spread);
• HMR is on (ngc's canDeferDeps = !enableHmr);
• the template uses selectorless components or directives;
• it is a pipe.

Without cross-file analysis nothing changes: test_defer_with_only_imports_does_not_auto_detect still passes, and only its comment changed.

Differences from ngc

• One resolver per component. ngc's full compilation uses DeferBlockDepsEmitMode.PerBlock, one dependency function per @defer block with only that block's dependencies. This uses the PerComponent resolver that deferredImports already emits, so the first @defer to trigger loads every implicitly deferred import. Per-block functions would need DeferMetadata::PerBlock.blocks filled before ingest, which is a larger change.
• One import used by two components in one file stays eager. If two components in the same file both defer LazyCmp, or each defers a different specifier of one import declaration, OXC keeps them eager. ngc defers them, because it checks canDefer after every component in the file is analysed. The output is safe; it only misses a lazy load.
• Pipes stay eager. Telling whether a pipe is used only inside @defer needs a walk over every binding expression, which OXC doesn't have yet.

Tests

tests/defer_implicit_imports_test.rs compiles real files in a temp directory with resolve_imported_values on. It has 37 cases:

• used only inside @defer, also used outside, in a @placeholder, in a nested @switch, aliased, a default export, referenced elsewhere, an attribute directive, a bound input, not standalone, a pipe, next to an explicit deferredImports entry, HMR;
• selector matching: SVG elements and xlink: attributes, i18n* attributes, upper-case CLASS, :not(...)-only selectors, an empty selector in a list, a binding over a static attribute, the placeholder of a nested @defer;
• emitted code: a jit: true sibling that injects the class (declared first and last), a default import in a sibling's setClassMetadata, a computed type key, a sibling specifier used eagerly / used as a value / an interface / in deferredImports, all specifiers deferred, inline type specifiers;
• cross-file lookup: a namespace member next to an unexported class (with and without export { LazyCmp as Alias }), class Impl {} export { Impl as LazyCmp }, a computed decorator key.

Each guard has a case that fails without it. selector.rs has unit tests for the matcher.

cargo fmt --all -- --check, cargo test --all-features (3326 passed) and cargo run -p oxc_angular_conformance (1264/1264, no snapshot diff) pass.

[Copilot]

Copilot was unable to review this pull request because the user who requested the review has reached their quota limit.

An organization owner can choose the repository organization as the billing source for reviews requested by members with a paid Copilot license. Learn about Copilot code review billing. Review the Copilot code review billing settings.

[Brooooooklyn]

@codex review

[chatgpt-codex-connector]

Codex Review: Didn't find any major issues. What shall we delve into next?

Reviewed commit: 9fa794f4a7

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".