@softarc/native-federation 4.2.0 → 4.3.0

package/README.md

@@ -1,6 +1,6 @@
 # @softarc/native-federation
 
-Native Federation is a "browser-native" implementation of the successful mental model behind wepback Module Federation for building Micro Frontends and plugin-based solutions. It can be **used with any framework and build tool** for implementing **Micro Frontends** and plugin-based architectures.
+Native Federation is a "browser-native" implementation of the successful mental model behind webpack Module Federation. It can be **used with any framework and build tool** for implementing **Micro Frontends** and plugin-based architectures.
 
 > [!WARNING]
 > **This is our v4 version**. For the v3 version, check out the [module-federation-plugin repository](https://github.com/angular-architects/module-federation-plugin/tree/main/libs/native-federation-core).
@@ -35,7 +35,7 @@ For this, the mental model introduces several concepts:
 
 - **Remote:** The remote is a separately built and deployed application. It can **expose EcmaScript** modules that can be loaded into other applications.
 - **Host:** The host loads one or several remotes on demand. For your framework's perspective, this looks like traditional lazy loading. The big difference is that the host doesn't know the remotes at compilation time.
-- **Shared Dependencies:** If a several remotes and the host use the same library, you might not want to download it several times. Instead, you might want to just download it once and share it at runtime. For this use case, the mental model allows for defining such shared dependencies.
+- **Shared Dependencies:** If several remotes and the host use the same library, you might not want to download it several times. Instead, you might want to just download it once and share it at runtime. For this use case, the mental model allows for defining such shared dependencies.
 - **Version Mismatch:** If two or more applications use a different version of the same shared library, we need to prevent a version mismatch. To deal with it, the mental model defines several strategies, like falling back to another version that fits the application, using a different compatible one (according to semantic versioning) or throwing an error.
 
 ## Example
@@ -52,8 +52,8 @@ For this, the mental model introduces several concepts:
 Big thanks to:
 
 - [Zack Jackson](https://twitter.com/ScriptedAlchemy) for originally coming up with the great idea of Module Federation and its successful mental model
-- [Florian Rappl](https://twitter.com/FlorianRappl) for an good discussion about these topics during a speakers dinner in Nuremberg
-- [Michael Egger-Zikes](https://twitter.com/MikeZks) for contributing to our Module Federation efforts and brining in valuable feedback
+- [Florian Rappl](https://twitter.com/FlorianRappl) for a good discussion about these topics during a speakers dinner in Nuremberg
+- [Michael Egger-Zikes](https://twitter.com/MikeZks) for contributing to our Module Federation efforts and bringing in valuable feedback
 - The Angular CLI-Team, esp. [Alan Agius](https://twitter.com/AlanAgius4) and [Charles Lyding](https://twitter.com/charleslyding), for working on the experimental esbuild builder for Angular
 
 ## Using this Library
@@ -143,9 +143,78 @@ The method `federationBuilder.build` bundles the shared and exposed parts of you
 
 ### Configuring Hosts
 
-The `withNativeFederation` function sets up a configuration for your applications. This is an example configuration for a host:
+The `withNativeFederation` function sets up a configuration for your applications. This is an example configuration for a host.
 
-The `shareAll` helper shares all your dependencies defined in your `package.json`. The `package.json` is look up as described above:
+#### The `fromPackageJson` helper (recommended)
+
+`fromPackageJson` is the recommended way to share your dependencies. It shares **all** dependencies found in your `package.json` and exposes a small fluent builder so you can fine-tune the result. The base options you pass are applied to every shared dependency; you then chain `.skip(...)`, `.override(...)` and `.patch(...)` as needed and finish with `.get()`:
+
+```typescript
+// shell/federation.config.js
+
+import { withNativeFederation, fromPackageJson } from '@softarc/native-federation/config';
+
+export default withNativeFederation({
+  name: 'host',
+
+  shared: fromPackageJson({
+    singleton: true,
+    strictVersion: true,
+    requiredVersion: 'auto',
+    includeSecondaries: false,
+  }).get(),
+});
+```
+
+> [!TIP]
+> If you omit the `shared` property entirely, Native Federation applies exactly this `fromPackageJson` configuration for you (with `singleton`, `strictVersion` and `requiredVersion: 'auto'`). So the snippet above is also a good description of the default behavior.
+
+The builder returned by `fromPackageJson` offers three chainable methods, each of which returns the builder so you can combine them:
+
+- **`.skip(externals)`** — exclude packages from sharing (added on top of the [default skip list](#sharing)).
+- **`.override(externals)`** — replace the configuration for specific packages entirely. Use this when a package needs a completely different set of options.
+- **`.patch(externals, cfg)`** — merge a partial configuration onto specific shared externals, keeping the base options for everything you don't touch.
+
+```typescript
+// shell/federation.config.js
+
+import { withNativeFederation, fromPackageJson } from '@softarc/native-federation/config';
+
+export default withNativeFederation({
+  name: 'host',
+
+  shared: fromPackageJson({
+    singleton: true,
+    strictVersion: true,
+    requiredVersion: 'auto',
+  })
+    // Don't share these dependencies at all
+    .skip(['my-lib', 'some-dev-only-lib'])
+    // Give a package a completely different configuration
+    .override({
+      'package-a/themes/xyz': {
+        singleton: true,
+        strictVersion: true,
+        requiredVersion: 'auto',
+        includeSecondaries: { skip: '@package-a/themes/xyz/*' },
+        build: 'package',
+      },
+    })
+    // Tweak a few options on specific packages while keeping the base config
+    .patch(['package-b'], {
+      singleton: false,
+      includeSecondaries: { skip: 'package-b/icons/*' },
+      build: 'package',
+    })
+    .get(),
+});
+```
+
+By default the closest `package.json` (relative to your `federation.config.js`) is used. You can point at a different one by passing its path as the second argument: `fromPackageJson(baseCfg, projectPath)`.
+
+#### Alternative: the `shareAll` helper
+
+`shareAll` is the older, object-spread style alternative to `fromPackageJson`. It also shares all dependencies defined in your `package.json`, but instead of a fluent builder it returns a plain object that you spread into `shared`:
 
 ```typescript
 // shell/federation.config.js
@@ -166,11 +235,9 @@ export default withNativeFederation({
 });
 ```
 
-The options passed to shareAll are applied to all dependencies found in your `package.json`.
+The options passed to `shareAll` are applied to all dependencies found in your `package.json`. This might come in handy in a monorepo scenario and when doing some experiments / troubleshooting.
 
-This might come in handy in an mono repo scenario and when doing some experiments/ trouble shooting.
-
-> Since v21.1 it's also possible to add overrides to the shareAll for specific packages.
+You can also add overrides to `shareAll` for specific packages, via the second argument:
 
 ```typescript
 // shell/federation.config.js
@@ -226,17 +293,17 @@ shared: share({
 })
 ```
 
-The added options are `requireVersion: 'auto'` and `includeSecondaries`.
+The added options are `requiredVersion: 'auto'` and `includeSecondaries`.
 
-#### requireVersion: 'auto'
+#### requiredVersion: 'auto'
 
-If you set `requireVersion` to `'auto'`, the helper takes the version defined in your `package.json`.
+If you set `requiredVersion` to `'auto'`, the helper takes the version defined in your `package.json`.
 
-This helps to solve issues with not (fully) met peer dependencies and secondary entry points (see Pitfalls section below).
+This helps to solve issues with not (fully) met peer dependencies and secondary entry points.
 
-By default, it takes the `package.json` that is closest to the caller (normally the `webpack.config.js`). However, you can pass the path to an other `package.json` using the second optional parameter. Also, you need to define the shared libray within the node dependencies in your `package.json`.
+By default, it takes the `package.json` that is closest to the caller (normally the `federation.config.js`). However, you can pass the path to another `package.json` using the second optional parameter. Also, you need to define the shared library within the dependencies in your `package.json`.
 
-Instead of setting requireVersion to auto time and again, you can also skip this option and call `setInferVersion(true)` before:
+Instead of setting `requiredVersion` to `auto` time and again, you can also skip this option and call `setInferVersion(true)` before:
 
 ```typescript
 setInferVersion(true);
@@ -268,7 +335,7 @@ shared: share({
 })
 ```
 
-By default, all entrypoints of a package are considered, you can disable expensive glob resolves using the `globResolve` property:
+Wildcard (`*`) export entry points are not expanded by default. To resolve them into concrete secondary entry points, enable the `resolveGlob` property:
 
 ```typescript
 shared: share({
@@ -282,7 +349,7 @@ shared: share({
 })
 ```
 
-This is enabled by default but might not always desirable since it will create a bundle of every valid exported file it finds, **Therefore it is recommended not to disable the `ignoreUnusedDeps` feature**. If you want to specifically skip certain parts of the glob export, you can also use the wildcard in the skip section:
+Resolving globs can create a bundle for every valid exported file it finds, **so it is recommended to keep the `ignoreUnusedDeps` feature enabled** (it is on by default) to drop the ones you don't use. If you want to specifically skip certain parts of the glob export, you can also use the wildcard in the skip section:
 
 ```typescript
 shared: share({
@@ -296,7 +363,7 @@ shared: share({
 })
 ```
 
-Finally, it's also possible to break out of the "removeUnusedDep" feature for specific externals if desired, for example when sharing a whole suite of interconnected external dependencies like @angular/core. This can be handy when you want to avoid the chance of cross-version secondary entrypoints being used by the different micro frontends. E.g. mfe1 uses @angular/core v20.1.0 and mfe2 uses @angular/core/rxjs-interop v20.0.8, then you might want to use consistent use of v20.1.0 so rxjs-interop should be exported by mfe1. The "keepAll" prop allows you to enforce this:
+Finally, it's also possible to break out of the `ignoreUnusedDeps` feature for specific externals if desired, for example when sharing a whole suite of interconnected external dependencies like @angular/core. This can be handy when you want to avoid the chance of cross-version secondary entrypoints being used by the different micro frontends. E.g. mfe1 uses @angular/core v20.1.0 and mfe2 uses @angular/core/rxjs-interop v20.0.8, then you might want consistent use of v20.1.0 so rxjs-interop should be exported by mfe1. The `keepAll` prop allows you to enforce this:
 
 ```typescript
 shared: share({
@@ -310,14 +377,13 @@ shared: share({
 })
 ```
 
-The API for configuring and using Native Federation is very similar to the one provided by our Module Federation plugin [@angular-architects/module-federation](https://www.npmjs.com/package/@angular-architects/native-federation). Hence, most the articles on it are also valid for Native Federation.
+The API for configuring and using Native Federation is very similar to the one provided by our Module Federation plugin [@angular-architects/module-federation](https://www.npmjs.com/package/@angular-architects/module-federation). Hence, most of the articles on it are also valid for Native Federation.
 
 ### Sharing
 
 The `shareAll`-helper used here shares all dependencies found in your `package.json`. Hence, they only need to be loaded once (instead of once per remote and host). If you don't want to share all of them, you can opt-out of sharing by using the `skip` option:
 
 ```typescript
-n
 export default withNativeFederation({
   [...]
 
@@ -332,7 +398,7 @@ export default withNativeFederation({
 
 ### Sharing Mapped Paths (Monorepo-internal Libraries)
 
-Paths mapped in your `tsconfig.json` are shared by default too. While they are part of your (mono) repository, they are treaded like libraries:
+Paths mapped in your `tsconfig.json` are shared by default too. While they are part of your (mono) repository, they are treated like libraries:
 
 ```json
 {
@@ -349,7 +415,7 @@ Paths mapped in your `tsconfig.json` are shared by default too. While they are p
 
 If you don't want to share (all of) them, put their names into the skip array (see above).
 
-### Detemining which internal libraries are shared
+### Determining which internal libraries are shared
 
 In Nx/monorepo setups, Native Federation shares all libraries from your `tsconfig` path mappings by default.
 
@@ -376,7 +442,9 @@ Notes:
 - Mapped paths are read from the workspace root tsconfig file: `tsconfig.base.json` if present, otherwise `tsconfig.json`.
 - The workspace root is detected by searching upward from the current working directory until a `package.json` is found.
 
-If you don't want to share libraries within a monorepo and also distribute them as built libraries with a version, disable the `mappingVersion` feature flag in your `federation.config.js`. This ensures that the corresponding versions from your buildable libraries are used.
+The `mappingVersion` feature flag controls whether mapped paths get a version. It is **enabled by default**: Native Federation reads the version from the mapped library's nearest `package.json` and shares it with strict versioning, just like a published library.
+
+If your mapped paths point at plain internal source that isn't distributed as a versioned, buildable library, you can disable it. The mapped paths are then shared without a version constraint.
 
 ```js
 module.exports = withNativeFederation({
@@ -394,11 +462,9 @@ module.exports = withNativeFederation({
 });
 ```
 
-If enabled, Native Federation tries to read the version from the mapped library's nearest `package.json`. By default this feature is set to `false`.
-
 ### Code-Splitting for Shared Dependencies
 
-By default, Native Federation enables code-splitting (chunking) for shared dependencies. This means large libraries can be split into smaller chunks which reduces the overal size, improving initial load times.
+By default, Native Federation enables code-splitting (chunking) for shared dependencies. This means large libraries can be split into smaller chunks which reduces the overall size, improving initial load times.
 
 You can configure code-splitting at two levels:
 
@@ -436,18 +502,19 @@ module.exports = withNativeFederation({
         strictVersion: true,
         requiredVersion: 'auto',
       },
-      overrides: {
-        'large-lib': {
-          singleton: true,
-          strictVersion: true,
-          requiredVersion: 'auto',
-          chunks: false,
-          build: 'package' // necessary for isolated bundles
+      {
+        overrides: {
+          // Disable code-splitting for a specific package
+          'large-lib': {
+            singleton: true,
+            strictVersion: true,
+            requiredVersion: 'auto',
+            chunks: false,
+            build: 'package', // necessary for isolated bundles
+          },
         },
       }
     ),
-    // Disable code-splitting for a specific package
-
   },
 });
 ```
@@ -475,6 +542,27 @@ module.exports = withNativeFederation({
 
 When enabled, instead of listing each chunk as a separate shared dependency, chunks are grouped by bundle name in a dedicated `chunks` object. Each shared dependency gets a `bundle` property linking it to its chunk bundle. This results in a smaller `remoteEntry.json` and allows chunks to be skipped if the dependency is not used in the final import map.
 
+#### Dense Externals
+
+The `denseExternals` feature flag reshapes the `shared` array in `remoteEntry.json` so that all entrypoints of a shared external (its primary import plus every secondary and shared mapping) are grouped under a single object:
+
+```js
+module.exports = withNativeFederation({
+  shared: {
+    ...shareAll({
+      singleton: true,
+      strictVersion: true,
+      requiredVersion: 'auto',
+    }),
+  },
+  features: {
+    denseExternals: true,
+  },
+});
+```
+
+When enabled, instead of one flat entry per entrypoint, each package becomes one object whose `entries` map keys the full import name to its output file (e.g. `{ "@angular/common": "...", "@angular/common/http": "..." }`). Entrypoints whose sharing metadata (`singleton`, `strictVersion`, `requiredVersion`, `version`, `shareScope`) diverges are split into separate groups. Bundler chunks stay flat, and `importmap.json` is unaffected. The flag is opt-in and fully backward compatible: the runtime auto-detects each entry by shape, so old and new `remoteEntry.json` both load.
+
 ### Configuring Remotes
 
 When configuring a remote, you can expose files that can be loaded into the shell at runtime:
@@ -597,11 +685,11 @@ const { loadRemoteModule } = await initFederation(manifest, {
 
 ## React and Other CommonJS Libs
 
-Native Federation uses Web Standards like EcmaScript Modules. Most libs and frameworks support them meanwhile. Unfortunately, React still uses CommonJS (und UMD). We do our best to convert these libs to EcmaScript Modules. In the case of React there are some challenges due to the dynamic way the React bundles use the `exports` object.
+Native Federation uses Web Standards like EcmaScript Modules. Most libs and frameworks support them meanwhile. Unfortunately, React still uses CommonJS (and UMD). We do our best to convert these libs to EcmaScript Modules. In the case of React there are some challenges due to the dynamic way the React bundles use the `exports` object.
 
-As the community is moving to EcmaScrpt Modules, we expect that these issues will vanish over time. In between, we provide some solutions for dealing with CommonJS-based libraries using `exports` in a dynamic way.
+As the community is moving to EcmaScript Modules, we expect that these issues will vanish over time. In between, we provide some solutions for dealing with CommonJS-based libraries using `exports` in a dynamic way.
 
-One of them is `fileReplacemnts`:
+One of them is `fileReplacements`:
 
 ```javascript
 import { reactReplacements } from '@softarc/native-federation-esbuild/src/lib/react-replacements';

package/dist/config.d.ts

@@ -1,4 +1,6 @@
 export * from './lib/domain/config/index.js';
 export { withNativeFederation } from './lib/config/with-native-federation.js';
-export { findRootTsConfigJson, share, shareAll, setInferVersion, } from './lib/config/share-utils.js';
+export { findRootTsConfigJson } from './lib/config/project-paths.js';
+export { setInferVersion } from './lib/config/version-lookup.js';
+export { share, shareAll, fromPackageJson } from './lib/config/share-utils.js';
 export { DEFAULT_SKIP_LIST } from './lib/config/default-skip-list.js';

package/dist/config.js

@@ -1,15 +1,13 @@
 export * from "./lib/domain/config/index.js";
 import { withNativeFederation } from "./lib/config/with-native-federation.js";
-import {
-  findRootTsConfigJson,
-  share,
-  shareAll,
-  setInferVersion
-} from "./lib/config/share-utils.js";
+import { findRootTsConfigJson } from "./lib/config/project-paths.js";
+import { setInferVersion } from "./lib/config/version-lookup.js";
+import { share, shareAll, fromPackageJson } from "./lib/config/share-utils.js";
 import { DEFAULT_SKIP_LIST } from "./lib/config/default-skip-list.js";
 export {
   DEFAULT_SKIP_LIST,
   findRootTsConfigJson,
+  fromPackageJson,
   setInferVersion,
   share,
   shareAll,

package/dist/internal.d.ts

@@ -10,5 +10,6 @@ export type { NormalizedFederationConfig } from './lib/domain/config/federation-
 export { getDefaultCachePath, getChecksum } from './lib/core/cache/cache-persistence.js';
 export { isESMExport, type ExportCondition, type ExportEntry, } from './lib/utils/package/package-info.js';
 export { isInSkipList, prepareSkipList } from './lib/config/default-skip-list.js';
-export type { NfFileWatcher, NfFileWatcherOptions } from './lib/domain/utils/file-watcher.contract.js';
+export { densifyExternals } from './lib/core/output/densify-externals.js';
+export type { NfFileWatcher, NfFileWatcherOptions, } from './lib/domain/utils/file-watcher.contract.js';
 export { syncNfFileWatcher, createNfWatcher } from './lib/utils/file-watcher.js';

package/dist/internal.js

@@ -9,10 +9,12 @@ import {
   isESMExport
 } from "./lib/utils/package/package-info.js";
 import { isInSkipList, prepareSkipList } from "./lib/config/default-skip-list.js";
+import { densifyExternals } from "./lib/core/output/densify-externals.js";
 import { syncNfFileWatcher, createNfWatcher } from "./lib/utils/file-watcher.js";
 export {
   RebuildQueue,
   createNfWatcher,
+  densifyExternals,
   getChecksum,
   getDefaultCachePath,
   hashFile,

package/dist/lib/config/project-paths.d.ts

@@ -0,0 +1,5 @@
+import type { FileReaderPort } from '../domain/utils/io-port.contract.js';
+export declare function findRootTsConfigJson(): string;
+export declare function findRootTsConfigJsonCore(io: FileReaderPort): string;
+export declare function findPackageJson(io: FileReaderPort, folder: string): string;
+export declare function inferProjectPath(projectPath: string | undefined): string;

package/dist/lib/config/project-paths.js

@@ -0,0 +1,49 @@
+import * as path from "path";
+import { cwd } from "process";
+import { getConfigContext } from "./configuration-context.js";
+import { nodeIo } from "../utils/io/node-io-adapter.js";
+function findRootTsConfigJson() {
+  return findRootTsConfigJsonCore(nodeIo);
+}
+function findRootTsConfigJsonCore(io) {
+  const packageJson = findPackageJson(io, cwd());
+  const projectRoot = path.dirname(packageJson);
+  const tsConfigBaseJson = path.join(projectRoot, "tsconfig.base.json");
+  const tsConfigJson = path.join(projectRoot, "tsconfig.json");
+  if (io.exists(tsConfigBaseJson)) {
+    return tsConfigBaseJson;
+  } else if (io.exists(tsConfigJson)) {
+    return tsConfigJson;
+  }
+  throw new Error("Neither a tsconfig.json nor a tsconfig.base.json was found");
+}
+function findPackageJson(io, folder) {
+  while (!io.exists(path.join(folder, "package.json")) && path.dirname(folder) !== folder) {
+    folder = path.dirname(folder);
+  }
+  const filePath = path.join(folder, "package.json");
+  if (io.exists(filePath)) {
+    return filePath;
+  }
+  throw new Error(
+    "no package.json found. Searched the following folder and all parents: " + folder
+  );
+}
+function inferProjectPath(projectPath) {
+  if (!projectPath && getConfigContext().packageJson) {
+    projectPath = path.dirname(getConfigContext().packageJson || "");
+  }
+  if (!projectPath && getConfigContext().workspaceRoot) {
+    projectPath = getConfigContext().workspaceRoot || "";
+  }
+  if (!projectPath) {
+    projectPath = cwd();
+  }
+  return projectPath;
+}
+export {
+  findPackageJson,
+  findRootTsConfigJson,
+  findRootTsConfigJsonCore,
+  inferProjectPath
+};

package/dist/lib/config/secondaries.d.ts

@@ -0,0 +1,5 @@
+import { type PreparedSkipList } from '../domain/config/skip-list.contract.js';
+import type { FileReaderPort, GlobPort } from '../domain/utils/io-port.contract.js';
+import type { ExternalConfig, IncludeSecondariesOptions, SharedExternalsConfig } from '../domain/config/external-config.contract.js';
+export declare function getSecondaries(io: FileReaderPort & GlobPort, includeSecondaries: IncludeSecondariesOptions, libPath: string, key: string, shareObject: ExternalConfig, preparedSkipList: PreparedSkipList): SharedExternalsConfig | null;
+export declare function addSecondaries(secondaries: Record<string, ExternalConfig>, result: Record<string, ExternalConfig>): void;

package/dist/lib/config/secondaries.js

@@ -0,0 +1,186 @@
+import * as path from "path";
+import { isInSkipList } from "./default-skip-list.js";
+import { resolvePackageJsonExportsWildcardCore } from "../utils/package/resolve-wildcard-keys.js";
+import { logger } from "../utils/logger.js";
+function _findSecondaries(io, libPath, excludes, shareObject, acc, preparedSkipList) {
+  const files = io.readDir(libPath);
+  const secondaries = files.map((f) => path.join(libPath, f)).filter((f) => io.isDirectory(f) && !f.endsWith("node_modules"));
+  for (const s of secondaries) {
+    if (io.exists(path.join(s, "package.json"))) {
+      const secondaryLibName = s.replace(/\\/g, "/").replace(/^.*node_modules[/]/, "");
+      const inCustomSkipList = excludes.some(
+        (e) => e === secondaryLibName || e.endsWith("*") && secondaryLibName.startsWith(e.slice(0, -1))
+      );
+      if (inCustomSkipList) continue;
+      if (isInSkipList(secondaryLibName, preparedSkipList)) {
+        continue;
+      }
+      acc[secondaryLibName] = { ...shareObject };
+    }
+    _findSecondaries(io, s, excludes, shareObject, acc, preparedSkipList);
+  }
+}
+function findSecondaries(io, libPath, excludes, shareObject, preparedSkipList) {
+  const acc = {};
+  _findSecondaries(io, libPath, excludes, shareObject, acc, preparedSkipList);
+  return acc;
+}
+function getSecondaries(io, includeSecondaries, libPath, key, shareObject, preparedSkipList) {
+  let exclude = [];
+  let resolveGlob = false;
+  if (typeof includeSecondaries === "object") {
+    if (includeSecondaries.skip) {
+      if (Array.isArray(includeSecondaries.skip)) {
+        exclude = includeSecondaries.skip;
+      } else if (typeof includeSecondaries.skip === "string") {
+        exclude = [includeSecondaries.skip];
+      }
+    }
+    resolveGlob = !!includeSecondaries.resolveGlob;
+  }
+  if (!io.exists(libPath)) {
+    return {};
+  }
+  const configured = readConfiguredSecondaries(
+    io,
+    key,
+    libPath,
+    exclude,
+    shareObject,
+    preparedSkipList,
+    resolveGlob
+  );
+  if (configured) {
+    return configured;
+  }
+  const secondaries = findSecondaries(io, libPath, exclude, shareObject, preparedSkipList);
+  return secondaries;
+}
+function readConfiguredSecondaries(io, parent, libPath, exclude, shareObject, preparedSkipList, resolveGlob) {
+  const libPackageJson = path.join(libPath, "package.json");
+  if (!io.exists(libPackageJson)) {
+    return null;
+  }
+  const packageJson = JSON.parse(io.readText(libPackageJson));
+  const version = packageJson["version"];
+  const esm = packageJson["type"] === "module";
+  const exports = packageJson["exports"];
+  if (!exports) {
+    return null;
+  }
+  const keys = Object.keys(exports).filter(
+    (key) => key !== "." && key !== "./package.json" && key.startsWith("./") && (exports[key]?.["default"] || exports[key]?.["import"] || typeof exports[key] === "string")
+  );
+  const result = {};
+  const discoveredFiles = /* @__PURE__ */ new Set();
+  for (const key of keys) {
+    const secondaryName = path.join(parent, key).replace(/\\/g, "/");
+    const inCustomSkipList = exclude.some(
+      (e) => e === secondaryName || e.endsWith("*") && secondaryName.startsWith(e.slice(0, -1))
+    );
+    if (inCustomSkipList) continue;
+    if (isInSkipList(secondaryName, preparedSkipList)) {
+      continue;
+    }
+    const entry = getDefaultEntry(exports, key);
+    if (typeof entry !== "string") {
+      logger.warn("No entry point found for " + secondaryName);
+      continue;
+    }
+    if (!key.includes("*") && !isJsFile(entry)) {
+      continue;
+    }
+    const items = resolveGlobSecondaries(
+      io,
+      key,
+      libPath,
+      parent,
+      secondaryName,
+      entry,
+      { discovered: discoveredFiles, skip: exclude },
+      resolveGlob
+    );
+    items.forEach((e) => discoveredFiles.add(typeof e === "string" ? e : e.value));
+    for (const item of items) {
+      if (typeof item === "object") {
+        result[item.key] = {
+          ...shareObject,
+          packageInfo: {
+            entryPoint: item.value,
+            version: shareObject.version ?? version,
+            esm
+          }
+        };
+      } else {
+        result[item] = {
+          ...shareObject
+        };
+      }
+    }
+  }
+  return result;
+}
+function resolveGlobSecondaries(io, key, libPath, parent, secondaryName, entry, excludes, resolveGlob) {
+  let items = [];
+  if (key.includes("*")) {
+    if (!resolveGlob) return items;
+    const expanded = resolvePackageJsonExportsWildcardCore(io, key, entry, libPath);
+    items = expanded.map((e) => ({
+      key: path.join(parent, e.key),
+      value: path.join(libPath, e.value)
+    })).filter((i) => {
+      if (!isJsFile(i.value)) {
+        return false;
+      }
+      if (excludes.skip.some(
+        (e) => e.endsWith("*") ? i.key.startsWith(e.slice(0, -1)) : e === i.key
+      )) {
+        return false;
+      }
+      if (excludes.discovered.has(i.value)) {
+        return false;
+      }
+      return true;
+    });
+  } else {
+    items = [secondaryName];
+  }
+  return items;
+}
+function isJsFile(file) {
+  return file.endsWith(".js") || file.endsWith(".mjs") || file.endsWith(".cjs");
+}
+function getDefaultEntry(exports, key) {
+  let entry = "";
+  if (typeof exports[key] === "string") {
+    entry = exports[key];
+  }
+  if (!entry) {
+    entry = exports[key]?.["default"];
+    if (typeof entry === "object") {
+      entry = entry["default"];
+    }
+  }
+  if (!entry) {
+    entry = exports[key]?.["import"];
+    if (typeof entry === "object") {
+      entry = entry["import"] ?? entry["default"];
+    }
+  }
+  if (!entry) {
+    entry = exports[key]?.["require"];
+    if (typeof entry === "object") {
+      entry = entry["require"] ?? entry["default"];
+    }
+  }
+  return entry;
+}
+function addSecondaries(secondaries, result) {
+  for (const key in secondaries) {
+    result[key] = secondaries[key];
+  }
+}
+export {
+  addSecondaries,
+  getSecondaries
+};

package/dist/lib/config/share-utils.d.ts

@@ -1,20 +1,23 @@
-import { type SkipList, type PreparedSkipList } from '../domain/config/skip-list.contract.js';
+import { type SkipList } from '../domain/config/skip-list.contract.js';
 import type { PackageJsonRepository } from '../domain/utils/package-json.contract.js';
 import type { FileReaderPort, GlobPort } from '../domain/utils/io-port.contract.js';
-import type { ExternalConfig, IncludeSecondariesOptions, ShareAllExternalsOptions, SharedExternalsConfig, ShareExternalsOptions } from '../domain/config/external-config.contract.js';
-export declare function findRootTsConfigJson(): string;
-export declare function findRootTsConfigJsonCore(io: FileReaderPort): string;
-export declare function getSecondaries(io: FileReaderPort & GlobPort, includeSecondaries: IncludeSecondariesOptions, libPath: string, key: string, shareObject: ExternalConfig, preparedSkipList: PreparedSkipList): SharedExternalsConfig | null;
+import type { ExternalConfig, ResolvedSharedExternalsConfig, ShareAllExternalsOptions, ShareExternalsOptions } from '../domain/config/external-config.contract.js';
+export declare const fromPackageJson: (baseCfg: ShareAllExternalsOptions, projectPath?: string) => {
+    skip(externals: SkipList): /*elided*/ any;
+    override(externals: ShareExternalsOptions): /*elided*/ any;
+    patch(externals: string[], cfg: Partial<ExternalConfig>): /*elided*/ any;
+    get(): ResolvedSharedExternalsConfig;
+};
 export declare function shareAll(config: ShareAllExternalsOptions, opts?: {
     skipList?: SkipList;
     projectPath?: string;
     overrides?: ShareExternalsOptions;
-}): ShareExternalsOptions | null;
+}): ResolvedSharedExternalsConfig;
 export declare function shareAllCore(io: FileReaderPort & GlobPort, config: ShareAllExternalsOptions, opts?: {
     skipList?: SkipList;
     projectPath?: string;
     overrides?: ShareExternalsOptions;
-}, repo?: PackageJsonRepository): ShareExternalsOptions | null;
-export declare function setInferVersion(infer: boolean): void;
-export declare function share(configuredShareObjects: ShareExternalsOptions, projectPath?: string, skipList?: SkipList): ShareExternalsOptions;
-export declare function shareCore(io: FileReaderPort & GlobPort, configuredShareObjects: ShareExternalsOptions, projectPath?: string, skipList?: SkipList, repo?: PackageJsonRepository): ShareExternalsOptions;
+    patchList?: Record<string, Partial<ExternalConfig>>;
+}, repo?: PackageJsonRepository): ResolvedSharedExternalsConfig;
+export declare function share(configuredShareObjects: ShareExternalsOptions, projectPath?: string, skipList?: SkipList): ResolvedSharedExternalsConfig;
+export declare function shareCore(io: FileReaderPort & GlobPort, configuredShareObjects: ShareExternalsOptions, projectPath?: string, skipList?: SkipList, repo?: PackageJsonRepository): ResolvedSharedExternalsConfig;