v0.11.0: builder parity — close all parity:important issues

Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/cli", "crates/diagnostics", "crates/project-resolver", "crates/ts-transform", "crates/bundler", "crates/template-compiler", "crates/npm-resolver", "crates/linker", "crates/watch", "crates/dev-server"]
 
 [workspace.package]
-version = "0.10.8"
+version = "0.11.0"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 authors = ["lukekania"]

README.md

@@ -116,11 +116,16 @@ When an `angular.json` is found, ngc-rs reads styles, assets, polyfills, and fil
 
 ### `ngc-rs serve`
 
-Build the project, watch for source changes, and host `dist/` over HTTP with live reload — the `ng serve` equivalent for everyday Angular development:
+Build the project, watch for source changes, and host `dist/` over HTTP (or HTTPS) with live reload — the `ng serve` equivalent for everyday Angular development:
 
 ```sh
 ngc-rs serve --project tsconfig.app.json
 ngc-rs serve --project tsconfig.app.json --host 0.0.0.0 --port 4300 --open
+
+# HTTPS with an auto-generated self-signed certificate (browsers show the
+# usual untrusted-certificate warning), or pass your own cert/key:
+ngc-rs serve --project tsconfig.app.json --ssl
+ngc-rs serve --project tsconfig.app.json --ssl --ssl-key dev.key --ssl-cert dev.crt
 ```
 
 ## Benchmark comparison

crates/bundler/src/npm_wrap.rs

@@ -15,7 +15,7 @@
 //! })(__ns_abc123);
 //! ```
 
-use std::collections::{BTreeSet, HashMap};
+use std::collections::{BTreeSet, HashMap, HashSet};
 use std::path::Path;
 
 use ngc_diagnostics::{NgcError, NgcResult};
@@ -39,15 +39,29 @@ pub struct NpmModuleInfo {
 ///
 /// `resolve_import` is a closure that maps an import specifier to a namespace
 /// variable name, or `None` if the import should be left as-is (truly external).
+///
+/// `unused_exports` carries the set of exported names that per-provider
+/// shake decided no consumer reaches. When provided, both the declarations
+/// (`export const X = ...`) and the matching `__exports.X = ...` bridge
+/// lines are dropped, shrinking vendor chunks of large packages like
+/// `@angular/core` whose `index.mjs` re-exports far more than any consumer
+/// actually uses.
 pub fn wrap_npm_module<F>(
     js_code: &str,
     file_name: &str,
     namespace: &str,
+    unused_exports: Option<&HashSet<String>>,
     resolve_import: F,
 ) -> NgcResult<NpmModuleInfo>
 where
     F: Fn(&str) -> Option<String>,
 {
+    let is_unused = |name: &str| -> bool {
+        unused_exports
+            .map(|set| set.contains(name))
+            .unwrap_or(false)
+    };
+
     // Strip sourcemap comments upfront to prevent them from interfering with
     // the IIFE wrapping (they can eat export assignments on the same line).
     let cleaned_code = strip_sourcemap_comments(js_code);
@@ -133,6 +147,9 @@ where
                         for spec in &export.specifiers {
                             let exported = spec.exported.name().to_string();
                             let local = spec.local.name().to_string();
+                            if is_unused(&exported) {
+                                continue;
+                            }
                             // Don't add to exported_names — we handle the export inline
                             if let Some(ref ns) = target_ns {
                                 replacements.push(format!("__exports.{exported} = {ns}.{local};"));
@@ -150,21 +167,39 @@ where
                             end: export.span.end,
                             replacement,
                         });
-                    } else if export.declaration.is_some() {
-                        // export const X = ...; → strip "export "
-                        if let Some(decl) = &export.declaration {
-                            collect_decl_names(decl, &mut exported_names);
+                    } else if let Some(decl) = &export.declaration {
+                        // export const X = ...; — if X is unused, drop the
+                        // entire declaration so the body isn't pinned by
+                        // its `__exports.X = X` line and any const
+                        // initializer side-effect is also eliminated.
+                        let mut decl_names = Vec::new();
+                        collect_decl_names(decl, &mut decl_names);
+                        let all_unused =
+                            !decl_names.is_empty() && decl_names.iter().all(|n| is_unused(n));
+                        if all_unused {
+                            edits.push(TextEdit {
+                                start: export.span.start,
+                                end: export.span.end,
+                                replacement: None,
+                            });
+                        } else {
+                            for n in &decl_names {
+                                exported_names.push(n.clone());
+                            }
+                            edits.push(TextEdit {
+                                start: export.span.start,
+                                end: export.span.start + 7, // "export "
+                                replacement: None,
+                            });
                         }
-                        edits.push(TextEdit {
-                            start: export.span.start,
-                            end: export.span.start + 7, // "export "
-                            replacement: None,
-                        });
                     } else {
                         // export { X, Y }; or export { X as Y }; → collect names and remove
                         for spec in &export.specifiers {
                             let exported = spec.exported.name().to_string();
                             let local = spec.local.name().to_string();
+                            if is_unused(&exported) {
+                                continue;
+                            }
                             if exported != local {
                                 renamed_exports.insert(exported.clone(), local);
                             }
@@ -428,7 +463,7 @@ mod tests {
     #[test]
     fn test_wrap_simple_module() {
         let code = "export function hello() { return 42; }\n";
-        let result = wrap_npm_module(code, "test.js", "__ns_test", no_resolve).unwrap();
+        let result = wrap_npm_module(code, "test.js", "__ns_test", None, no_resolve).unwrap();
         assert!(result.wrapped_code.contains("var __ns_test = {};"));
         assert!(result.wrapped_code.contains("(function(__exports)"));
         assert!(result.wrapped_code.contains("__exports.hello = hello;"));
@@ -447,7 +482,7 @@ mod tests {
                 None
             }
         };
-        let result = wrap_npm_module(code, "test.js", "__ns_test", resolve).unwrap();
+        let result = wrap_npm_module(code, "test.js", "__ns_test", None, resolve).unwrap();
         assert!(result
             .wrapped_code
             .contains("var Component = __ns_core.Component;"));
@@ -465,7 +500,7 @@ mod tests {
                 None
             }
         };
-        let result = wrap_npm_module(code, "test.js", "__ns_test", resolve).unwrap();
+        let result = wrap_npm_module(code, "test.js", "__ns_test", None, resolve).unwrap();
         assert!(result
             .wrapped_code
             .contains("Object.assign(__exports, __ns_utils)"));
@@ -474,11 +509,43 @@ mod tests {
     #[test]
     fn test_wrap_default_export() {
         let code = "export default function helper() { return 1; }\n";
-        let result = wrap_npm_module(code, "test.js", "__ns_test", no_resolve).unwrap();
+        let result = wrap_npm_module(code, "test.js", "__ns_test", None, no_resolve).unwrap();
         assert!(result.wrapped_code.contains("function helper()"));
         assert!(result.wrapped_code.contains("__exports.default = helper;"));
     }
 
+    #[test]
+    fn test_wrap_drops_unused_declaration() {
+        let code = "export const used = 1;\nexport const unused = 2;\n";
+        let mut unused: HashSet<String> = HashSet::new();
+        unused.insert("unused".to_string());
+        let result =
+            wrap_npm_module(code, "test.js", "__ns_test", Some(&unused), no_resolve).unwrap();
+        assert!(result.wrapped_code.contains("const used = 1"));
+        assert!(!result.wrapped_code.contains("const unused = 2"));
+        assert!(result.wrapped_code.contains("__exports.used = used;"));
+        assert!(!result.wrapped_code.contains("__exports.unused"));
+    }
+
+    #[test]
+    fn test_wrap_drops_unused_reexport_bridge() {
+        let code = "export { used, unused } from './impl';\n";
+        let resolve = |spec: &str| -> Option<String> {
+            if spec == "./impl" {
+                Some("__ns_impl".to_string())
+            } else {
+                None
+            }
+        };
+        let mut unused: HashSet<String> = HashSet::new();
+        unused.insert("unused".to_string());
+        let result = wrap_npm_module(code, "test.js", "__ns_test", Some(&unused), resolve).unwrap();
+        assert!(result
+            .wrapped_code
+            .contains("__exports.used = __ns_impl.used"));
+        assert!(!result.wrapped_code.contains("__exports.unused"));
+    }
+
     #[test]
     fn test_namespace_from_path() {
         use std::path::PathBuf;

crates/bundler/src/rewrite.rs

@@ -66,6 +66,7 @@ pub fn rewrite_module(
         None,
         &HashSet::new(),
         &HashMap::new(),
+        &HashSet::new(),
         false,
     )
 }
@@ -83,6 +84,7 @@ pub fn rewrite_module_with_shaking(
     unused_exports: Option<&HashSet<String>>,
     bundled_specifiers: &HashSet<String>,
     namespace_map: &HashMap<String, String>,
+    external_specifiers: &HashSet<String>,
     preserve_exports: bool,
 ) -> NgcResult<RewrittenModule> {
     let allocator = Allocator::new();
@@ -116,6 +118,7 @@ pub fn rewrite_module_with_shaking(
                 unused_exports,
                 bundled_specifiers,
                 namespace_map,
+                external_specifiers,
                 preserve_exports,
             )
         } else {
@@ -158,12 +161,18 @@ fn collect_module_decl_edits(
     unused_exports: Option<&HashSet<String>>,
     bundled_specifiers: &HashSet<String>,
     namespace_map: &HashMap<String, String>,
+    external_specifiers: &HashSet<String>,
     preserve_exports: bool,
 ) -> bool {
     match module_decl {
         ModuleDeclaration::ImportDeclaration(import) => {
             let source = import.source.value.as_str();
-            if is_local(source, local_prefixes, bundled_specifiers) {
+            if is_local(
+                source,
+                local_prefixes,
+                bundled_specifiers,
+                external_specifiers,
+            ) {
                 // Check if this import has a namespace mapping (npm module)
                 if let Some(ns) = namespace_map.get(source) {
                     // Replace import with namespace lookups
@@ -326,6 +335,7 @@ fn collect_module_decl_edits(
                 export.source.value.as_str(),
                 local_prefixes,
                 bundled_specifiers,
+                external_specifiers,
             ) =>
         {
             edits.push(TextEdit {
@@ -774,17 +784,46 @@ fn get_declaration_name(decl: &oxc_ast::ast::Declaration) -> Option<String> {
 }
 
 /// Check if an import specifier is local based on known prefixes or bundled specifiers.
+///
+/// `external_specifiers` is a *veto* set — when a specifier matches one of
+/// its entries (by exact name or `<name>/...` subpath), it is treated as
+/// external no matter what else would classify it. This is how
+/// `angular.json`'s `externalDependencies` keeps imports like
+/// `import $ from 'jquery'` from being inlined.
 fn is_local(
     specifier: &str,
     local_prefixes: &[&str],
     bundled_specifiers: &HashSet<String>,
+    external_specifiers: &HashSet<String>,
 ) -> bool {
+    if matches_external_specifier(specifier, external_specifiers) {
+        return false;
+    }
     local_prefixes
         .iter()
         .any(|prefix| specifier.starts_with(prefix))
         || bundled_specifiers.contains(specifier)
 }
 
+/// Returns true when `specifier` is either an exact entry in
+/// `external_specifiers` or a subpath of one (e.g. `jquery/dist/jquery.slim`
+/// when `external_specifiers` lists `jquery`). Mirrors esbuild's `--external`
+/// matching, which is what `@angular/build:application` uses under the hood.
+pub(crate) fn matches_external_specifier(
+    specifier: &str,
+    external_specifiers: &HashSet<String>,
+) -> bool {
+    if external_specifiers.is_empty() {
+        return false;
+    }
+    if external_specifiers.contains(specifier) {
+        return true;
+    }
+    external_specifiers
+        .iter()
+        .any(|ext| specifier.starts_with(ext) && specifier[ext.len()..].starts_with('/'))
+}
+
 /// Apply text edits to the source, producing the rewritten code.
 fn apply_edits(source: &str, edits: &mut [TextEdit]) -> String {
     // Sort in reverse order so later edits don't shift earlier offsets
@@ -1094,6 +1133,7 @@ mod tests {
             Some(&unused),
             &HashSet::new(),
             &HashMap::new(),
+            &HashSet::new(),
             false,
         )
         .expect("should rewrite");
@@ -1128,6 +1168,7 @@ mod tests {
             Some(&empty_unused),
             &HashSet::new(),
             &HashMap::new(),
+            &HashSet::new(),
             false,
         )
         .expect("should rewrite");
@@ -1155,6 +1196,7 @@ mod tests {
             Some(&unused),
             &HashSet::new(),
             &HashMap::new(),
+            &HashSet::new(),
             false,
         )
         .expect("should rewrite");
@@ -1185,6 +1227,7 @@ mod tests {
             Some(&empty_unused),
             &HashSet::new(),
             &HashMap::new(),
+            &HashSet::new(),
             false,
         )
         .expect("should rewrite");