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

Author: alan-agius4

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

@@ -58,6 +58,7 @@ export interface PackageJsonData {
   scripts?: Record<string, string>;
   workspaces?: unknown;
   dependencies?: Record<string, string>;
+  optionalDependencies?: Record<string, string>;
   peerDependencies?: Record<string, string>;
   peerDependenciesMeta?: Record<string, { optional?: boolean }>;
   [key: string]: unknown;
@@ -157,7 +158,7 @@ export async function normalizeLibraryOptions(
     packageName,
   );
 
-  const allowedNonPeerDependencies: RegExp[] = [];
+  const allowedNonPeerDependencies: RegExp[] = [/^tslib$/];
   for (const pattern of rawAllowedNonPeerDependencies) {
     try {
       allowedNonPeerDependencies.push(new RegExp(pattern));
@@ -186,10 +187,12 @@ export async function normalizeLibraryOptions(
     });
   }
 
-  const combinedAssets = [...defaultAssets, ...(rawAssets ?? [])];
-  const assets = combinedAssets.length
-    ? normalizeAssetPatterns(combinedAssets, workspaceRoot, projectRoot, projectSourceRoot)
-    : [];
+  const assets = normalizeAssetPatterns(
+    [...defaultAssets, ...(rawAssets ?? [])],
+    workspaceRoot,
+    projectRoot,
+    projectSourceRoot,
+  );
 
   const cacheOptions = normalizeCacheOptions(projectMetadata, workspaceRoot);
 
@@ -237,19 +240,21 @@ export async function normalizeLibraryOptions(
  * Normalizes a single entry point specification.
  *
  * @param key The entry point key from package.json exports (e.g. '.' or './testing').
+ * @param posixKey Normalized POSIX key without trailing slashes.
+ * @param isPrimary Whether this is the primary entry point.
  * @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,
+  posixKey: string,
+  isPrimary: boolean,
   targetPath: string,
   projectRoot: string,
   packageName: string,
 ): NormalizedEntryPoint {
-  const posixKey = toPosixPath(key).replace(/\/+$/, '');
-  const isPrimary = posixKey === '.' || posixKey === '';
   const name = isPrimary
     ? '.'
     : posixKey[0] === '.' && posixKey[1] === '/'
@@ -264,11 +269,11 @@ function normalizeEntryPoint(
 
   const subpath = isPrimary ? '.' : `./${name}`;
   const displayName = isPrimary ? packageName : `${packageName}/${name}`;
-  const bundleName = getEntryPointBundleName(packageName, name, isPrimary);
+  const bundleName = getEntryPointBundleName(packageName, name);
 
   const entryFilePath = path.resolve(projectRoot, targetPath);
 
-  if (!/\.(?:ts|mts)$/.test(entryFilePath) || /\.d\.(?:ts|mts)$/.test(entryFilePath)) {
+  if (!/(?<!\.d)\.(?:ts|mts)$/.test(entryFilePath)) {
     throw new Error(
       `Entry point '${key}' file path must be a TypeScript file ('.ts' or '.mts'): '${entryFilePath}'.`,
     );
@@ -312,6 +317,7 @@ function normalizeEntryPoints(
 
   for (const [key, value] of Object.entries(exportsRecord)) {
     let target: string | undefined;
+
     if (typeof value === 'string') {
       target = value;
     } else if (
@@ -333,26 +339,33 @@ function normalizeEntryPoints(
             `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;
-      }
+    if (!isPrimary && !/\.m?ts$/.test(target)) {
+      // Static asset, stylesheet, or package.json export; preserve in package.json without compiling.
+      continue;
     }
 
-    const entryPoint = normalizeEntryPoint(key, target, projectRoot, packageName);
+    const entryPoint = normalizeEntryPoint(
+      key,
+      posixKey,
+      isPrimary,
+      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.`,
       );
     }
+
     entryPoints.set(entryPoint.name, entryPoint);
+
     if (entryPoint.isPrimary) {
       hasPrimary = true;
     }

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

@@ -6,6 +6,7 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 
+import { statSync } from 'node:fs';
 import path from 'node:path';
 import picomatch from 'picomatch';
 import { toPosixPath } from '../../../utils/path';
@@ -33,22 +34,44 @@ export async function collectAssetsToEmit(
     return [];
   }
 
-  const hasModifiedFiles = !!modifiedFiles?.size;
+  if (modifiedFiles) {
+    if (modifiedFiles.size === 0) {
+      return [];
+    }
 
-  if (hasModifiedFiles && !checkAssetChanges(assets, workspaceRoot, modifiedFiles)) {
-    return [];
+    const matchers = createAssetMatchers(assets, workspaceRoot);
+    const filesToEmit: DiskOutputFile[] = [];
+
+    for (const file of modifiedFiles) {
+      const resolvedFile = path.isAbsolute(file) ? file : path.resolve(workspaceRoot, file);
+      const posixFile = toPosixPath(resolvedFile);
+
+      for (const { asset, posixInputPrefix, isMatch } of matchers) {
+        if (!posixFile.startsWith(posixInputPrefix)) {
+          continue;
+        }
+
+        const relative = posixFile.slice(posixInputPrefix.length);
+        if (!isMatch(relative)) {
+          continue;
+        }
+
+        if (statSync(resolvedFile, { throwIfNoEntry: false })?.isFile()) {
+          filesToEmit.push(createDiskOutputFile(resolvedFile, path.join(asset.output, relative)));
+          allWatchedFiles.add(posixFile);
+        }
+      }
+    }
+
+    return filesToEmit;
   }
 
   const resolvedAssets = await resolveAssets(assets, workspaceRoot);
   const filesToEmit: DiskOutputFile[] = [];
 
   for (const { source, destination } of resolvedAssets) {
-    if (hasModifiedFiles && !modifiedFiles.has(toPosixPath(source))) {
-      continue;
-    }
-
     filesToEmit.push(createDiskOutputFile(source, destination));
-    allWatchedFiles.add(source);
+    allWatchedFiles.add(toPosixPath(source));
   }
 
   return filesToEmit;
@@ -71,16 +94,7 @@ export function checkAssetChanges(
     return false;
   }
 
-  const matchers = assets.map((asset) => {
-    const absInput = path.resolve(workspaceRoot, asset.input);
-    const posixInput = toPosixPath(absInput).replace(/\/+$/, '');
-    const isMatch = picomatch(asset.glob, {
-      dot: true,
-      ignore: [...DEFAULT_ASSET_IGNORE, ...(asset.ignore ?? [])],
-    });
-
-    return { posixInputPrefix: `${posixInput}/`, isMatch };
-  });
+  const matchers = createAssetMatchers(assets, workspaceRoot);
 
   for (const file of changedFiles) {
     const resolvedFile = path.isAbsolute(file) ? file : path.resolve(workspaceRoot, file);
@@ -98,3 +112,16 @@ export function checkAssetChanges(
 
   return false;
 }
+
+function createAssetMatchers(assets: NormalizedLibraryOptions['assets'], workspaceRoot: string) {
+  return assets.map((asset) => {
+    const absInput = path.resolve(workspaceRoot, asset.input);
+    const posixInput = toPosixPath(absInput).replace(/\/+$/, '');
+    const isMatch = picomatch(asset.glob, {
+      dot: true,
+      ignore: [...DEFAULT_ASSET_IGNORE, ...(asset.ignore ?? [])],
+    });
+
+    return { asset, posixInputPrefix: `${posixInput}/`, isMatch };
+  });
+}