fixup! feat(@angular/build): add library builder

Author: alan-agius4

packages/angular/build/src/builders/library/builder.ts

@@ -148,7 +148,6 @@ export async function* executeLibraryBuilder(
 
     for (const { entryPoint } of graph.nodes.values()) {
       allWatchedFiles.add(entryPoint.entryFilePath);
-      allWatchedFiles.add(entryPoint.tsConfigPath);
     }
 
     if (isWatchMode) {

packages/angular/build/src/builders/library/options.ts

@@ -41,9 +41,6 @@ export interface NormalizedEntryPoint {
   /** Absolute path to entry file. */
   entryFilePath: string;
 
-  /** Absolute path to tsConfig file for this entry point. */
-  tsConfigPath: string;
-
   /** Is this the primary entry point ('.')? */
   isPrimary: boolean;
 }
@@ -57,7 +54,7 @@ export interface PackageJsonData {
   typings?: string;
   types?: string;
   sideEffects?: boolean | string[];
-  exports?: Record<string, unknown>;
+  exports?: string | Record<string, unknown>;
   scripts?: Record<string, string>;
   workspaces?: unknown;
   dependencies?: Record<string, string>;
@@ -119,7 +116,6 @@ export async function normalizeLibraryOptions(
 
   const {
     tsConfig,
-    entryPoints: rawEntryPoints,
     assets: rawAssets,
     stylePreprocessorOptions,
     inlineStyleLanguage = 'css',
@@ -155,10 +151,9 @@ export async function normalizeLibraryOptions(
   }
 
   const entryPoints = normalizeEntryPoints(
-    rawEntryPoints,
-    workspaceRoot,
-    resolvedTsConfigPath,
-    projectName,
+    packageJson.exports,
+    projectRoot,
+    packageJsonPath,
     packageName,
   );
 
@@ -241,18 +236,16 @@ export async function normalizeLibraryOptions(
 /**
  * Normalizes a single entry point specification.
  *
- * @param key The entry point key from configuration (e.g. '.' or './testing').
- * @param value The entry point file path string or object with entryPoint and tsConfig.
- * @param workspaceRoot The workspace root directory.
- * @param defaultTsConfigPath The default tsConfig path for the project.
+ * @param key The entry point key from package.json exports (e.g. '.' or './testing').
+ * @param targetPath The relative file path string from exports.
+ * @param projectRoot The library project root directory.
  * @param packageName The root package name (e.g. `@my/lib`).
  * @returns The normalized entry point descriptor.
  */
 function normalizeEntryPoint(
   key: string,
-  value: LibraryBuilderOptions['entryPoints'][string],
-  workspaceRoot: string,
-  defaultTsConfigPath: string,
+  targetPath: string,
+  projectRoot: string,
   packageName: string,
 ): NormalizedEntryPoint {
   const posixKey = toPosixPath(key).replace(/\/+$/, '');
@@ -265,69 +258,95 @@ function normalizeEntryPoint(
 
   if (name !== '.' && (path.posix.isAbsolute(name) || name.includes('..'))) {
     throw new Error(
-      `Invalid entry point key '${key}'. Entry point keys must be relative subpaths without '..' (e.g. './testing' or 'testing').`,
+      `Invalid entry point key '${key}'. Entry point keys must be relative subpaths without '..' (e.g. './testing').`,
     );
   }
 
   const subpath = isPrimary ? '.' : `./${name}`;
   const displayName = isPrimary ? packageName : `${packageName}/${name}`;
   const bundleName = getEntryPointBundleName(packageName, name, isPrimary);
 
-  const entryFilePath = path.resolve(
-    workspaceRoot,
-    typeof value === 'string' ? value : value.entryPoint,
-  );
+  const entryFilePath = path.resolve(projectRoot, targetPath);
 
   if (!/\.(?:ts|mts)$/.test(entryFilePath) || /\.d\.(?:ts|mts)$/.test(entryFilePath)) {
     throw new Error(
       `Entry point '${key}' file path must be a TypeScript file ('.ts' or '.mts'): '${entryFilePath}'.`,
     );
   }
 
-  const tsConfigPath =
-    typeof value !== 'string' && value.tsConfig
-      ? path.resolve(workspaceRoot, value.tsConfig)
-      : defaultTsConfigPath;
-
   return {
     subpath,
     name,
     displayName,
     bundleName,
     entryFilePath,
-    tsConfigPath,
     isPrimary,
   };
 }
 
 /**
- * Normalizes all entry points for the library project.
+ * Normalizes all entry points from the library's `package.json` `exports` field.
  *
- * @param rawEntryPoints The raw entryPoints dictionary from schema options.
- * @param workspaceRoot The workspace root directory.
- * @param defaultTsConfigPath The default tsConfig path for the project.
- * @param projectName The project name used in error reporting.
+ * @param rawExports The `exports` field from `package.json`.
+ * @param projectRoot The library project root directory.
+ * @param packageJsonPath Path to `package.json` for error reporting.
  * @param packageName The root package name (e.g. `@my/lib`).
  * @returns A Map of normalized entry points keyed by name.
  */
 function normalizeEntryPoints(
-  rawEntryPoints: LibraryBuilderOptions['entryPoints'],
-  workspaceRoot: string,
-  defaultTsConfigPath: string,
-  projectName: string,
+  rawExports: PackageJsonData['exports'],
+  projectRoot: string,
+  packageJsonPath: string,
   packageName: string,
 ): Map<string, NormalizedEntryPoint> {
+  if (!rawExports || (typeof rawExports !== 'string' && typeof rawExports !== 'object')) {
+    throw new Error(
+      `The 'package.json' at '${packageJsonPath}' must contain an 'exports' field defining the primary entry point ('.').`,
+    );
+  }
+
+  const exportsRecord = typeof rawExports === 'string' ? { '.': rawExports } : rawExports;
+
   const entryPoints = new Map<string, NormalizedEntryPoint>();
   let hasPrimary = false;
 
-  for (const [key, value] of Object.entries(rawEntryPoints)) {
-    const entryPoint = normalizeEntryPoint(
-      key,
-      value,
-      workspaceRoot,
-      defaultTsConfigPath,
-      packageName,
-    );
+  for (const [key, value] of Object.entries(exportsRecord)) {
+    let target: string | undefined;
+    if (typeof value === 'string') {
+      target = value;
+    } else if (
+      typeof value === 'object' &&
+      value !== null &&
+      !Array.isArray(value) &&
+      typeof (value as Record<string, unknown>)['default'] === 'string'
+    ) {
+      target = (value as Record<string, unknown>)['default'] as string;
+    }
+
+    const posixKey = toPosixPath(key).replace(/\/+$/, '');
+    const isPrimary = posixKey === '.' || posixKey === '';
+
+    if (!target) {
+      if (isPrimary) {
+        throw new Error(
+          `The primary entry point '.' in '${packageJsonPath}' must specify a string path ` +
+            `or a 'default' condition pointing to a TypeScript file.`,
+        );
+      }
+      // Non-JS/TS conditional export (e.g., sass/style-only subpath); preserve in package.json without compiling.
+      continue;
+    }
+
+    if (!isPrimary) {
+      const isTsSource = /\.(?:ts|mts)$/.test(target) && !/\.d\.(?:ts|mts)$/.test(target);
+      const isInvalidCodeEntry = /\.(?:d\.[cm]?ts|cts|tsx|jsx)$/.test(target);
+      if (!isTsSource && !isInvalidCodeEntry) {
+        // Static asset, stylesheet, or package.json export; preserve in package.json without compiling.
+        continue;
+      }
+    }
+
+    const entryPoint = normalizeEntryPoint(key, target, projectRoot, packageName);
     if (entryPoints.has(entryPoint.name)) {
       throw new Error(
         `Duplicate entry point detected: '${key}' resolves to the same name ('${entryPoint.name}') as an existing entry point.`,
@@ -341,7 +360,7 @@ function normalizeEntryPoints(
 
   if (!hasPrimary) {
     throw new Error(
-      `The 'entryPoints' option in project '${projectName}' must contain a primary entry point with key '.'.`,
+      `The 'exports' field in '${packageJsonPath}' must contain a primary entry point with key '.'.`,
     );
   }
 

packages/angular/build/src/builders/library/pipeline/compilation.ts

@@ -82,6 +82,7 @@ export interface StylesheetBundlerAdapter {
 
 export type CompileEntryPointOptions = Pick<
   NormalizedLibraryOptions,
+  | 'tsConfigPath'
   | 'compilationMode'
   | 'declarationMap'
   | 'packageName'
@@ -113,8 +114,9 @@ export async function compileEntryPoint(
   upstreamDtsFiles?: Map<string, string>,
   sourceFileCache?: Map<string, ts.SourceFile>,
 ): Promise<CompilationResult> {
-  const { entryFilePath, tsConfigPath, bundleName } = entryPoint;
+  const { entryFilePath, bundleName } = entryPoint;
   const {
+    tsConfigPath,
     compilationMode,
     declarationMap,
     cacheOptions,

packages/angular/build/src/builders/library/pipeline/compiler-worker.ts

@@ -105,6 +105,7 @@ export async function compileEntryPointInWorker(
   modifiedFiles?: string[],
 ): Promise<CompilationOutput> {
   const workerOptions: CompileWorkerOptions = {
+    tsConfigPath: options.tsConfigPath,
     compilationMode: options.compilationMode,
     declarationMap: options.declarationMap,
     packageName: options.packageName,

packages/angular/build/src/builders/library/pipeline/entry-point-graph.ts

@@ -156,20 +156,18 @@ export class EntryPointGraph {
   private cachedNodeMeta?: Array<{
     node: EntryPointNode;
     entryFile: string;
-    tsConfig: string;
     dirWithSep: string;
   }>;
 
   private getNodeMeta() {
     this.cachedNodeMeta ??= Array.from(this.nodes.values())
       .map((node) => {
-        const { entryFilePath, tsConfigPath } = node.entryPoint;
+        const { entryFilePath } = node.entryPoint;
         const nodeDir = toPosixPath(path.dirname(entryFilePath));
 
         return {
           node,
           entryFile: toPosixPath(entryFilePath),
-          tsConfig: toPosixPath(tsConfigPath),
           dirWithSep: nodeDir.endsWith('/') ? nodeDir : `${nodeDir}/`,
         };
       })
@@ -191,8 +189,8 @@ export class EntryPointGraph {
     for (const file of changedFiles) {
       let matched = false;
 
-      for (const { node, entryFile, tsConfig } of nodeMeta) {
-        if (file === entryFile || file === tsConfig || node.referencedFiles.has(file)) {
+      for (const { node, entryFile } of nodeMeta) {
+        if (file === entryFile || node.referencedFiles.has(file)) {
           node.isDirty = true;
           hasChanges = true;
           matched = true;
@@ -329,7 +327,7 @@ export async function buildEntryPointGraph(
       for (const dep of dependencies) {
         if (!graph.nodes.has(dep)) {
           throw new Error(
-            `Entry point '${dep}' imported by '${entryPoint.name}' does not exist in 'entryPoints'.`,
+            `Entry point '${dep}' imported by '${entryPoint.name}' does not exist in 'package.json' exports.`,
           );
         }
 

packages/angular/build/src/builders/library/pipeline/package-manifests_spec.ts

@@ -86,7 +86,6 @@ describe('generatePackageManifests', () => {
       displayName: packageName,
       bundleName: primaryBundleName,
       entryFilePath: join(tempDir, 'src/public-api.ts'),
-      tsConfigPath: join(tempDir, 'tsconfig.lib.json'),
       isPrimary: true,
     });
 
@@ -98,7 +97,6 @@ describe('generatePackageManifests', () => {
         displayName: `${packageName}/testing`,
         bundleName: secondaryBundleName,
         entryFilePath: join(tempDir, 'testing/src/public-api.ts'),
-        tsConfigPath: join(tempDir, 'tsconfig.lib.json'),
         isPrimary: false,
       });
     }

packages/angular/build/src/builders/library/schema.json

@@ -4,22 +4,6 @@
   "description": "Library builder target options for Build Architect. Builds an Angular library package conforming to the Angular Package Format (APF).",
   "type": "object",
   "properties": {
-    "entryPoints": {
-      "type": "object",
-      "description": "Map of package entry points. The '.' key represents the primary entry point; other keys define secondary subpath entry points.",
-      "required": ["."],
-      "additionalProperties": {
-        "oneOf": [
-          {
-            "type": "string",
-            "description": "Path to the entry file (e.g. 'projects/my-lib/src/public-api.ts')."
-          },
-          {
-            "$ref": "#/definitions/entryPoint"
-          }
-        ]
-      }
-    },
     "tsConfig": {
       "type": "string",
       "description": "The full path for the TypeScript configuration file, relative to the current workspace root."
@@ -139,23 +123,8 @@
     }
   },
   "additionalProperties": false,
-  "required": ["tsConfig", "entryPoints"],
+  "required": ["tsConfig"],
   "definitions": {
-    "entryPoint": {
-      "type": "object",
-      "properties": {
-        "entryPoint": {
-          "type": "string",
-          "description": "Path to the entry file."
-        },
-        "tsConfig": {
-          "type": "string",
-          "description": "Optional TypeScript configuration file specific to this entry point."
-        }
-      },
-      "required": ["entryPoint"],
-      "additionalProperties": false
-    },
     "assetPattern": {
       "oneOf": [
         {

packages/angular/build/src/builders/library/tests/behavior/apf_spec.ts

@@ -21,12 +21,18 @@ describeLibraryBuilder(executeLibraryBuilder, LIBRARY_BUILDER_INFO, (harness) =>
         'projects/lib/secondary/src/public-api.ts': 'export const SECONDARY_VALUE = 42;\n',
       });
 
+      await harness.modifyFile('projects/lib/package.json', (content) => {
+        const pkg = JSON.parse(content);
+        pkg.exports = {
+          '.': './src/public-api.ts',
+          './secondary': './secondary/src/public-api.ts',
+        };
+
+        return JSON.stringify(pkg, null, 2);
+      });
+
       harness.useTarget('build', {
         ...BASE_OPTIONS,
-        entryPoints: {
-          '.': 'projects/lib/src/public-api.ts',
-          'secondary': 'projects/lib/secondary/src/public-api.ts',
-        },
         assets: [
           'projects/lib/README.md',
           'projects/lib/LICENSE',