@softarc/native-federation-orchestrator 4.6.1 → 4.7.0

package/types/lib/core/1.domain/externals/external.contract.d.ts

@@ -5,6 +5,7 @@ export declare const GLOBAL_SCOPE = "__GLOBAL__";
 export declare const STRICT_SCOPE = "strict";
 export type SharedExternal = {
     dirty: boolean;
+    poolName?: string;
     versions: SharedVersion[];
 };
 export type shareScope = Record<string, SharedExternal>;

package/types/lib/core/1.domain/externals/version.contract.d.ts

@@ -13,6 +13,7 @@ export type SharedVersion = Version & {
     remotes: SharedVersionMeta[];
 };
 export type SharedVersionAction = 'skip' | 'scope' | 'share';
+export type PoolCause = 'incompatible' | 'uncovered' | 'torn' | 'unshared';
 export type SharedVersionMeta = {
     requiredVersion: string;
     strictVersion: boolean;
@@ -22,4 +23,5 @@ export type SharedVersionMeta = {
     pool?: string;
     entries: Record<string, string>;
     servedBy?: RemoteName;
+    poolCause?: PoolCause;
 };

package/types/lib/core/2.app/config/index.d.ts

@@ -1,6 +1,7 @@
 export { ImportMapOptions, ImportMapConfig } from './import-map.contract';
 export { LoggingOptions, LogLevel, LogType, LoggingConfig, LogHandler, Logger, } from './log.contract';
-export { StorageOptions, StorageEntry, StorageEntryKey, StorageConfig } from './storage.contract';
+export { StorageOptions, StorageEntry, StorageEntryKey, StorageConfig, StorageType, StorageKey, } from './storage.contract';
+export { NFOrchestratorGlobal, NFOrchestratorStorageInfo } from './orchestrator-global.contract';
 export { ModeOptions, ModeConfig } from './mode.contract';
 export { HostOptions, HostConfig } from './host.contract';
 export { NFOptions, ConfigContract } from './config.contract';

package/types/lib/core/2.app/config/mode.contract.d.ts

@@ -8,7 +8,6 @@ export type ModeProfileConfig = {
 };
 export type ModeFeatureConfig = {
     convertFlatSharedInfo: boolean;
-    useAutoExternalPooling: boolean;
 };
 export type ModeStrictnessConfig = {
     strictRemoteEntry: boolean;

package/types/lib/core/2.app/config/orchestrator-global.contract.d.ts

@@ -0,0 +1,15 @@
+import type { StorageKey, StorageType } from './storage.contract';
+type NFOrchestratorStorageInfo = Readonly<{
+    version: string;
+    type: StorageType;
+    namespace: string;
+    keys: readonly StorageKey[];
+    get?: (key: string) => unknown;
+}>;
+type NFOrchestratorGlobal = Readonly<{
+    storage: Readonly<Record<string, NFOrchestratorStorageInfo>>;
+}>;
+declare global {
+    var __NF_ORCHESTRATOR__: NFOrchestratorGlobal | undefined;
+}
+export { NFOrchestratorGlobal, NFOrchestratorStorageInfo };

package/types/lib/core/2.app/config/storage.contract.d.ts

@@ -4,7 +4,18 @@ type StorageEntry<TValue> = {
     clear: () => StorageEntry<TValue>;
 };
 type StorageEntryKey = number | symbol | string;
-type StorageEntryCreator = (namespace: string) => StorageEntryHandler;
+type StorageType = 'globalThis' | 'localStorage' | 'sessionStorage' | 'custom';
+type StorageEntryCreator = {
+    (namespace: string): StorageEntryHandler;
+    type?: StorageType;
+};
+declare const STORAGE_KEYS: {
+    readonly remotes: "remotes";
+    readonly sharedExternals: "shared-externals";
+    readonly scopedExternals: "scoped-externals";
+    readonly sharedChunks: "shared-chunks";
+};
+type StorageKey = (typeof STORAGE_KEYS)[keyof typeof STORAGE_KEYS];
 type StorageEntryHandler = <TValue>(key: string, initialValue: TValue) => StorageEntry<TValue>;
 type StorageConfig = {
     storage: StorageEntryHandler;
@@ -14,5 +25,6 @@ type StorageOptions = {
     storage?: StorageEntryCreator;
     clearStorage?: boolean;
     storageNamespace?: string;
+    exposeStorageGetter?: boolean;
 };
-export { StorageEntry, StorageEntryKey, StorageEntryHandler, StorageConfig, StorageOptions, StorageEntryCreator, };
+export { StorageEntry, StorageEntryKey, StorageEntryHandler, StorageConfig, StorageOptions, StorageEntryCreator, StorageType, StorageKey, STORAGE_KEYS, };

package/types/lib/core/2.app/driving-ports/for-shared-externals-storage.port.d.ts

@@ -9,6 +9,6 @@ export type ForSharedExternalsStorage = {
     scopeType: (shareScope?: string) => 'global' | 'strict' | 'shareScope';
     removeFromAllScopes: (remoteNames: ReadonlySet<RemoteName>) => void;
     addOrUpdate: (name: string, external: SharedExternal, shareScope?: string) => ForSharedExternalsStorage;
-    hasPoolTag: (shareScope?: string) => boolean;
+    hasPoolState: (shareScope?: string) => boolean;
     commit: () => ForSharedExternalsStorage;
 };

package/types/lib/core/2.app/steps/pooling/pool-graph.d.ts

@@ -7,24 +7,19 @@ export type PoolEdge = {
 };
 export type PoolCandidate<T> = {
     name: ExternalName;
-    scope?: string;
     tags: readonly PoolEdge[];
-    remotes: readonly string[];
     value: T;
 };
-export declare function autoScope(name: string, useAutoExternalPooling: boolean): string | undefined;
 export declare function owningPackage(name: ExternalName): ExternalName | undefined;
 /**
  * Group one shareScope's candidates into pools by shared membership: pool = connected component of a
- * graph whose edges are all remote-local — `external -> scope@remote` for each remote that declares
- * it (auto-pooling) and `external -> tag@remote` for each declared tag — plus an unconditional
- * `entrypoint -> package` edge. A pool therefore forms exactly when some remote declares members
- * from both sides. See docs/version-resolver.md.
+ * graph whose edges are all remote-local — `external -> tag@remote` for each declared tag — plus an
+ * unconditional `entrypoint -> package` edge. See docs/version-resolver.md.
  *
- * Returns only real pools (>=2 members), keyed by and iterated in order of their canonical name
- * (smallest member — reload-stable). An explicit-tag member that pooled with nothing is warned
- * (likely typo or missing sibling); auto-scope singletons stay silent.
+ * Returns only real pools (>=2 members), keyed by `poolName` and iterated in order of their smallest
+ * member, which is what keeps the names reload-stable. A tagged member that pooled with nothing is warned
+ * (likely typo or missing sibling).
  */
 export declare function groupByMembership<T>(candidates: readonly PoolCandidate<T>[], log?: LogHandler): Map<PoolName, T[]>;
-/** Init-path grouping: build candidates from the stored shared externals of one shareScope. */
-export declare function buildPools(sharedExternals: shareScope, useAutoExternalPooling: boolean, log?: LogHandler): Map<PoolName, PoolMember[]>;
+/** Build candidates from the stored shared externals of one shareScope. */
+export declare function buildPools(sharedExternals: shareScope, log?: LogHandler): Map<PoolName, PoolMember[]>;

package/types/lib/core/2.app/steps/pooling/pool.util.d.ts

@@ -1,18 +1,19 @@
-import type { RemoteName } from '../../../1.domain';
+import type { RemoteName, shareScope } from '../../../1.domain';
 import type { ForSharedExternalsStorage } from '../../driving-ports/for-shared-externals-storage.port';
-import type { ModeConfig } from '../../config/mode.contract';
-import type { PoolMember } from './pool.types';
+import type { PoolMember, PoolName } from './pool.types';
 export declare function lazy<T>(make: () => T): () => T;
 export declare function remotesInPool(members: PoolMember[]): RemoteName[];
 /**
- * The scopes either pooling step has anything to do in. With auto-pooling off only a scope that carries a
- * `pool` tag of its own can pool anything, and a pool never spans share scopes — so one tag must not put
- * every other scope through a graph build. Auto-pooling on must never early-out, since any scoped package is
- * potentially poolable. The `strict` scope is never pooled.
+ * The scopes either pooling step has anything to do in. A pool never spans share scopes, so one tag must
+ * not put every other scope through a graph build. The `strict` scope is never pooled.
  *
  * Names only, so a caller that decides to skip a scope never reads it out of storage.
  */
-export declare function poolableScopes(config: ModeConfig, repo: Pick<ForSharedExternalsStorage, 'getScopes' | 'scopeType' | 'hasPoolTag'>): {
-    useAutoExternalPooling: boolean;
-    scopes: string[];
-};
+export declare function poolableScopes(repo: Pick<ForSharedExternalsStorage, 'getScopes' | 'scopeType' | 'hasPoolState'>): string[];
+/**
+ * Write `poolName` onto every external of the scope that is in a pool under a different name, and clear it —
+ * with every copy's `poolCause` — off one that is in none any more. Names are per scope (a suffix
+ * disambiguates two pools sharing a tag), so a pool nobody re-elected can still be renamed by another.
+ * `skip` names pools whose members the caller is rebuilding itself.
+ */
+export declare function syncPoolNames(sharedExternals: shareScope, pools: Map<PoolName, PoolMember[]>, repo: Pick<ForSharedExternalsStorage, 'addOrUpdate'>, scope: string, skip?: ReadonlySet<PoolName>): void;

package/types/lib/core/3.adapters/storage/chunk.repository.d.ts

@@ -1,4 +1,4 @@
-import type { StorageConfig } from '../../2.app/config/storage.contract';
+import { type StorageConfig } from '../../2.app/config/storage.contract';
 import type { ForSharedChunksStorage } from '../../2.app/driving-ports/for-shared-chunks-storage.port';
 declare const createChunkRepository: (config: StorageConfig) => ForSharedChunksStorage;
 export { createChunkRepository };

package/types/lib/core/3.adapters/storage/remote-info.repository.d.ts

@@ -1,4 +1,4 @@
-import type { StorageConfig } from '../../2.app/config/storage.contract';
+import { type StorageConfig } from '../../2.app/config/storage.contract';
 import type { ForRemoteInfoStorage } from '../../2.app/driving-ports/for-remote-info-storage.port';
 declare const createRemoteInfoRepository: (config: StorageConfig) => ForRemoteInfoStorage;
 export { createRemoteInfoRepository };

package/types/lib/core/3.adapters/storage/scoped-externals.repository.d.ts

@@ -1,4 +1,4 @@
-import type { StorageConfig } from '../../2.app/config/storage.contract';
+import { type StorageConfig } from '../../2.app/config/storage.contract';
 import type { ForScopedExternalsStorage } from '../../2.app/driving-ports/for-scoped-externals-storage.port';
 declare const createScopedExternalsRepository: (config: StorageConfig) => ForScopedExternalsStorage;
 export { createScopedExternalsRepository };

package/types/lib/core/3.adapters/storage/shared-externals.repository.d.ts

@@ -1,4 +1,4 @@
-import type { StorageConfig } from '../../2.app/config/storage.contract';
+import { type StorageConfig } from '../../2.app/config/storage.contract';
 import type { ForSharedExternalsStorage } from '../../2.app/driving-ports/for-shared-externals-storage.port';
 declare const createSharedExternalsRepository: (config: StorageConfig) => ForSharedExternalsStorage;
 export { createSharedExternalsRepository };

package/types/lib/core/4.config/storage/publish-storage-info.d.ts

@@ -0,0 +1,9 @@
+import { type StorageEntryHandler, type StorageType } from '../../2.app/config/storage.contract';
+type StorageInfoOptions = {
+    type: StorageType;
+    namespace: string;
+    storage: StorageEntryHandler;
+    exposeGetter: boolean;
+};
+export declare const publishStorageInfo: (options: StorageInfoOptions) => void;
+export {};

package/types/lib/testing/pooling/tag-by-npm-scope.d.ts

@@ -0,0 +1,9 @@
+import type { shareScope } from '../../core/1.domain';
+export declare const npmScope: (name: string) => string | undefined;
+/** Remote-entry side: tags each untagged scoped `shared` item, returning new objects. */
+export declare const tagSharedInfoByNpmScope: <T extends {
+    packageName: string;
+    pool?: string;
+}>(shared: readonly T[]) => T[];
+/** Storage side: tags every untagged copy of a scoped external in place, returning the same record. */
+export declare const tagStoredByNpmScope: <T extends shareScope>(externals: T) => T;