@softarc/native-federation-runtime 1.1.1 → 2.0.0

package/{fesm2020 → fesm2022}/softarc-native-federation-runtime.mjs

@@ -1,202 +1,202 @@
-function mergeImportMaps(map1, map2) {
-    return {
-        imports: { ...map1.imports, ...map2.imports },
-        scopes: { ...map1.scopes, ...map2.scopes },
-    };
+function mergeImportMaps(map1, map2) {
+    return {
+        imports: { ...map1.imports, ...map2.imports },
+        scopes: { ...map1.scopes, ...map2.scopes },
+    };
 }
 
-const externals = new Map();
-function getExternalKey(shared) {
-    return `${shared.packageName}@${shared.version}`;
-}
-function getExternalUrl(shared) {
-    const packageKey = getExternalKey(shared);
-    return externals.get(packageKey);
-}
-function setExternalUrl(shared, url) {
-    const packageKey = getExternalKey(shared);
-    externals.set(packageKey, url);
+const externals = new Map();
+function getExternalKey(shared) {
+    return `${shared.packageName}@${shared.version}`;
+}
+function getExternalUrl(shared) {
+    const packageKey = getExternalKey(shared);
+    return externals.get(packageKey);
+}
+function setExternalUrl(shared, url) {
+    const packageKey = getExternalKey(shared);
+    externals.set(packageKey, url);
 }
 
-function getDirectory(url) {
-    const parts = url.split('/');
-    parts.pop();
-    return parts.join('/');
-}
-function joinPaths(path1, path2) {
-    while (path1.endsWith('/')) {
-        path1 = path1.substring(0, path1.length - 1);
-    }
-    if (path2.startsWith('./')) {
-        path2 = path2.substring(2, path2.length);
-    }
-    return `${path1}/${path2}`;
+function getDirectory(url) {
+    const parts = url.split('/');
+    parts.pop();
+    return parts.join('/');
+}
+function joinPaths(path1, path2) {
+    while (path1.endsWith('/')) {
+        path1 = path1.substring(0, path1.length - 1);
+    }
+    if (path2.startsWith('./')) {
+        path2 = path2.substring(2, path2.length);
+    }
+    return `${path1}/${path2}`;
 }
 
-const remoteNamesToRemote = new Map();
-const baseUrlToRemoteNames = new Map();
-function addRemote(remoteName, remote) {
-    remoteNamesToRemote.set(remoteName, remote);
-    baseUrlToRemoteNames.set(remote.baseUrl, remoteName);
-}
-function getRemoteNameByBaseUrl(baseUrl) {
-    return baseUrlToRemoteNames.get(baseUrl);
-}
-function isRemoteInitialized(baseUrl) {
-    return baseUrlToRemoteNames.has(baseUrl);
-}
-function getRemote(remoteName) {
-    return remoteNamesToRemote.get(remoteName);
-}
-function hasRemote(remoteName) {
-    return remoteNamesToRemote.has(remoteName);
+const remoteNamesToRemote = new Map();
+const baseUrlToRemoteNames = new Map();
+function addRemote(remoteName, remote) {
+    remoteNamesToRemote.set(remoteName, remote);
+    baseUrlToRemoteNames.set(remote.baseUrl, remoteName);
+}
+function getRemoteNameByBaseUrl(baseUrl) {
+    return baseUrlToRemoteNames.get(baseUrl);
+}
+function isRemoteInitialized(baseUrl) {
+    return baseUrlToRemoteNames.has(baseUrl);
+}
+function getRemote(remoteName) {
+    return remoteNamesToRemote.get(remoteName);
+}
+function hasRemote(remoteName) {
+    return remoteNamesToRemote.has(remoteName);
 }
 
-function appendImportMap(importMap) {
-    document.body.appendChild(Object.assign(document.createElement('script'), {
-        type: 'importmap-shim',
-        innerHTML: JSON.stringify(importMap),
-    }));
+function appendImportMap(importMap) {
+    document.body.appendChild(Object.assign(document.createElement('script'), {
+        type: 'importmap-shim',
+        innerHTML: JSON.stringify(importMap),
+    }));
 }
 
-async function initFederation(remotesOrManifestUrl = {}) {
-    const remotes = typeof remotesOrManifestUrl === 'string'
-        ? await loadManifest(remotesOrManifestUrl)
-        : remotesOrManifestUrl;
-    const hostImportMap = await processHostInfo();
-    const remotesImportMap = await processRemoteInfos(remotes);
-    const importMap = mergeImportMaps(hostImportMap, remotesImportMap);
-    appendImportMap(importMap);
-    return importMap;
-}
-async function loadManifest(remotes) {
-    return (await fetch(remotes).then((r) => r.json()));
-}
-async function processRemoteInfos(remotes) {
-    let importMap = {
-        imports: {},
-        scopes: {},
-    };
-    for (const remoteName of Object.keys(remotes)) {
-        try {
-            const url = remotes[remoteName];
-            const remoteMap = await processRemoteInfo(url, remoteName);
-            importMap = mergeImportMaps(importMap, remoteMap);
-        }
-        catch (e) {
-            console.error(`Error loading remote entry for ${remoteName} from file ${remotes[remoteName]}`);
-        }
-    }
-    return importMap;
-}
-async function processRemoteInfo(federationInfoUrl, remoteName) {
-    const baseUrl = getDirectory(federationInfoUrl);
-    const remoteInfo = await loadFederationInfo(federationInfoUrl);
-    if (!remoteName) {
-        remoteName = remoteInfo.name;
-    }
-    const importMap = createRemoteImportMap(remoteInfo, remoteName, baseUrl);
-    addRemote(remoteName, { ...remoteInfo, baseUrl });
-    return importMap;
-}
-function createRemoteImportMap(remoteInfo, remoteName, baseUrl) {
-    const imports = processExposed(remoteInfo, remoteName, baseUrl);
-    const scopes = processRemoteImports(remoteInfo, baseUrl);
-    return { imports, scopes };
-}
-async function loadFederationInfo(url) {
-    const info = (await fetch(url).then((r) => r.json()));
-    return info;
-}
-function processRemoteImports(remoteInfo, baseUrl) {
-    const scopes = {};
-    const scopedImports = {};
-    for (const shared of remoteInfo.shared) {
-        const outFileName = getExternalUrl(shared) ?? joinPaths(baseUrl, shared.outFileName);
-        setExternalUrl(shared, outFileName);
-        scopedImports[shared.packageName] = outFileName;
-    }
-    scopes[baseUrl + '/'] = scopedImports;
-    return scopes;
-}
-function processExposed(remoteInfo, remoteName, baseUrl) {
-    const imports = {};
-    for (const exposed of remoteInfo.exposes) {
-        const key = joinPaths(remoteName, exposed.key);
-        const value = joinPaths(baseUrl, exposed.outFileName);
-        imports[key] = value;
-    }
-    return imports;
-}
-async function processHostInfo() {
-    const hostInfo = await loadFederationInfo('./remoteEntry.json');
-    const imports = hostInfo.shared.reduce((acc, cur) => ({ ...acc, [cur.packageName]: './' + cur.outFileName }), {});
-    for (const shared of hostInfo.shared) {
-        setExternalUrl(shared, './' + shared.outFileName);
-    }
-    return { imports, scopes: {} };
+async function initFederation(remotesOrManifestUrl = {}) {
+    const remotes = typeof remotesOrManifestUrl === 'string'
+        ? await loadManifest(remotesOrManifestUrl)
+        : remotesOrManifestUrl;
+    const hostImportMap = await processHostInfo();
+    const remotesImportMap = await processRemoteInfos(remotes);
+    const importMap = mergeImportMaps(hostImportMap, remotesImportMap);
+    appendImportMap(importMap);
+    return importMap;
+}
+async function loadManifest(remotes) {
+    return (await fetch(remotes).then((r) => r.json()));
+}
+async function processRemoteInfos(remotes) {
+    let importMap = {
+        imports: {},
+        scopes: {},
+    };
+    for (const remoteName of Object.keys(remotes)) {
+        try {
+            const url = remotes[remoteName];
+            const remoteMap = await processRemoteInfo(url, remoteName);
+            importMap = mergeImportMaps(importMap, remoteMap);
+        }
+        catch (e) {
+            console.error(`Error loading remote entry for ${remoteName} from file ${remotes[remoteName]}`);
+        }
+    }
+    return importMap;
+}
+async function processRemoteInfo(federationInfoUrl, remoteName) {
+    const baseUrl = getDirectory(federationInfoUrl);
+    const remoteInfo = await loadFederationInfo(federationInfoUrl);
+    if (!remoteName) {
+        remoteName = remoteInfo.name;
+    }
+    const importMap = createRemoteImportMap(remoteInfo, remoteName, baseUrl);
+    addRemote(remoteName, { ...remoteInfo, baseUrl });
+    return importMap;
+}
+function createRemoteImportMap(remoteInfo, remoteName, baseUrl) {
+    const imports = processExposed(remoteInfo, remoteName, baseUrl);
+    const scopes = processRemoteImports(remoteInfo, baseUrl);
+    return { imports, scopes };
+}
+async function loadFederationInfo(url) {
+    const info = (await fetch(url).then((r) => r.json()));
+    return info;
+}
+function processRemoteImports(remoteInfo, baseUrl) {
+    const scopes = {};
+    const scopedImports = {};
+    for (const shared of remoteInfo.shared) {
+        const outFileName = getExternalUrl(shared) ?? joinPaths(baseUrl, shared.outFileName);
+        setExternalUrl(shared, outFileName);
+        scopedImports[shared.packageName] = outFileName;
+    }
+    scopes[baseUrl + '/'] = scopedImports;
+    return scopes;
+}
+function processExposed(remoteInfo, remoteName, baseUrl) {
+    const imports = {};
+    for (const exposed of remoteInfo.exposes) {
+        const key = joinPaths(remoteName, exposed.key);
+        const value = joinPaths(baseUrl, exposed.outFileName);
+        imports[key] = value;
+    }
+    return imports;
+}
+async function processHostInfo() {
+    const hostInfo = await loadFederationInfo('./remoteEntry.json');
+    const imports = hostInfo.shared.reduce((acc, cur) => ({ ...acc, [cur.packageName]: './' + cur.outFileName }), {});
+    for (const shared of hostInfo.shared) {
+        setExternalUrl(shared, './' + shared.outFileName);
+    }
+    return { imports, scopes: {} };
 }
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-async function loadRemoteModule(optionsOrRemoteName, exposedModule) {
-    const options = normalizeOptions(optionsOrRemoteName, exposedModule);
-    await ensureRemoteInitialized(options);
-    const remoteName = getRemoteNameByOptions(options);
-    const remote = getRemote(remoteName);
-    if (!remote) {
-        throw new Error('unknown remote ' + remoteName);
-    }
-    const exposed = remote.exposes.find((e) => e.key === options.exposedModule);
-    if (!exposed) {
-        throw new Error(`Unknown exposed module ${options.exposedModule} in remote ${remoteName}`);
-    }
-    const url = joinPaths(remote.baseUrl, exposed.outFileName);
-    const module = await importShim(url);
-    return module;
-}
-function getRemoteNameByOptions(options) {
-    let remoteName;
-    if (options.remoteName) {
-        remoteName = options.remoteName;
-    }
-    else if (options.remoteEntry) {
-        const baseUrl = getDirectory(options.remoteEntry);
-        remoteName = getRemoteNameByBaseUrl(baseUrl);
-    }
-    else {
-        throw new Error('unexpcted arguments: Please pass remoteName or remoteEntry');
-    }
-    if (!remoteName) {
-        throw new Error('unknown remoteName ' + remoteName);
-    }
-    return remoteName;
-}
-async function ensureRemoteInitialized(options) {
-    if (options.remoteEntry &&
-        !isRemoteInitialized(getDirectory(options.remoteEntry))) {
-        const importMap = await processRemoteInfo(options.remoteEntry);
-        appendImportMap(importMap);
-    }
-}
-function normalizeOptions(optionsOrRemoteName, exposedModule) {
-    let options;
-    if (typeof optionsOrRemoteName === 'string' && exposedModule) {
-        options = {
-            remoteName: optionsOrRemoteName,
-            exposedModule,
-        };
-    }
-    else if (typeof optionsOrRemoteName === 'object' && !exposedModule) {
-        options = optionsOrRemoteName;
-    }
-    else {
-        throw new Error('unexpected arguments: please pass options or a remoteName/exposedModule-pair');
-    }
-    return options;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+async function loadRemoteModule(optionsOrRemoteName, exposedModule) {
+    const options = normalizeOptions(optionsOrRemoteName, exposedModule);
+    await ensureRemoteInitialized(options);
+    const remoteName = getRemoteNameByOptions(options);
+    const remote = getRemote(remoteName);
+    if (!remote) {
+        throw new Error('unknown remote ' + remoteName);
+    }
+    const exposed = remote.exposes.find((e) => e.key === options.exposedModule);
+    if (!exposed) {
+        throw new Error(`Unknown exposed module ${options.exposedModule} in remote ${remoteName}`);
+    }
+    const url = joinPaths(remote.baseUrl, exposed.outFileName);
+    const module = await importShim(url);
+    return module;
+}
+function getRemoteNameByOptions(options) {
+    let remoteName;
+    if (options.remoteName) {
+        remoteName = options.remoteName;
+    }
+    else if (options.remoteEntry) {
+        const baseUrl = getDirectory(options.remoteEntry);
+        remoteName = getRemoteNameByBaseUrl(baseUrl);
+    }
+    else {
+        throw new Error('unexpcted arguments: Please pass remoteName or remoteEntry');
+    }
+    if (!remoteName) {
+        throw new Error('unknown remoteName ' + remoteName);
+    }
+    return remoteName;
+}
+async function ensureRemoteInitialized(options) {
+    if (options.remoteEntry &&
+        !isRemoteInitialized(getDirectory(options.remoteEntry))) {
+        const importMap = await processRemoteInfo(options.remoteEntry);
+        appendImportMap(importMap);
+    }
+}
+function normalizeOptions(optionsOrRemoteName, exposedModule) {
+    let options;
+    if (typeof optionsOrRemoteName === 'string' && exposedModule) {
+        options = {
+            remoteName: optionsOrRemoteName,
+            exposedModule,
+        };
+    }
+    else if (typeof optionsOrRemoteName === 'object' && !exposedModule) {
+        options = optionsOrRemoteName;
+    }
+    else {
+        throw new Error('unexpected arguments: please pass options or a remoteName/exposedModule-pair');
+    }
+    return options;
 }
 
-/**
- * Generated bundle index. Do not edit.
+/**
+ * Generated bundle index. Do not edit.
  */
 
 export { initFederation, loadRemoteModule, processRemoteInfo };

package/index.d.ts

@@ -1,3 +1,3 @@
-export * from './lib/init-federation';
-export * from './lib/load-remote-module';
-export * from './lib/model/federation-info';
+export * from './lib/init-federation';
+export * from './lib/load-remote-module';
+export * from './lib/model/federation-info';

package/lib/init-federation.d.ts

@@ -1,3 +1,3 @@
-import { ImportMap } from './model/import-map';
-export declare function initFederation(remotesOrManifestUrl?: Record<string, string> | string): Promise<ImportMap>;
-export declare function processRemoteInfo(federationInfoUrl: string, remoteName?: string): Promise<ImportMap>;
+import { ImportMap } from './model/import-map';
+export declare function initFederation(remotesOrManifestUrl?: Record<string, string> | string): Promise<ImportMap>;
+export declare function processRemoteInfo(federationInfoUrl: string, remoteName?: string): Promise<ImportMap>;

package/lib/load-remote-module.d.ts

@@ -1,7 +1,7 @@
-export declare type LoadRemoteModuleOptions = {
-    remoteEntry?: string;
-    remoteName?: string;
-    exposedModule: string;
-};
-export declare function loadRemoteModule<T = any>(options: LoadRemoteModuleOptions): Promise<T>;
-export declare function loadRemoteModule<T = any>(remoteName: string, exposedModule: string): Promise<T>;
+export type LoadRemoteModuleOptions = {
+    remoteEntry?: string;
+    remoteName?: string;
+    exposedModule: string;
+};
+export declare function loadRemoteModule<T = any>(options: LoadRemoteModuleOptions): Promise<T>;
+export declare function loadRemoteModule<T = any>(remoteName: string, exposedModule: string): Promise<T>;

package/lib/model/externals.d.ts

@@ -1,3 +1,3 @@
-import { SharedInfo } from './federation-info';
-export declare function getExternalUrl(shared: SharedInfo): string | undefined;
-export declare function setExternalUrl(shared: SharedInfo, url: string): void;
+import { SharedInfo } from './federation-info';
+export declare function getExternalUrl(shared: SharedInfo): string | undefined;
+export declare function setExternalUrl(shared: SharedInfo, url: string): void;

package/lib/model/federation-info.d.ts

@@ -1,23 +1,23 @@
-export declare type SharedInfo = {
-    singleton: boolean;
-    strictVersion: boolean;
-    requiredVersion: string;
-    version?: string;
-    packageName: string;
-    outFileName: string;
-    dev?: {
-        entryPoint: string;
-    };
-};
-export interface ExposesInfo {
-    key: string;
-    outFileName: string;
-    dev?: {
-        entryPoint: string;
-    };
-}
-export interface FederationInfo {
-    name: string;
-    exposes: ExposesInfo[];
-    shared: SharedInfo[];
-}
+export type SharedInfo = {
+    singleton: boolean;
+    strictVersion: boolean;
+    requiredVersion: string;
+    version?: string;
+    packageName: string;
+    outFileName: string;
+    dev?: {
+        entryPoint: string;
+    };
+};
+export interface ExposesInfo {
+    key: string;
+    outFileName: string;
+    dev?: {
+        entryPoint: string;
+    };
+}
+export interface FederationInfo {
+    name: string;
+    exposes: ExposesInfo[];
+    shared: SharedInfo[];
+}

package/lib/model/import-map.d.ts

@@ -1,7 +1,7 @@
-export declare type Imports = Record<string, string>;
-export declare type Scopes = Record<string, Imports>;
-export declare type ImportMap = {
-    imports: Imports;
-    scopes: Scopes;
-};
-export declare function mergeImportMaps(map1: ImportMap, map2: ImportMap): ImportMap;
+export type Imports = Record<string, string>;
+export type Scopes = Record<string, Imports>;
+export type ImportMap = {
+    imports: Imports;
+    scopes: Scopes;
+};
+export declare function mergeImportMaps(map1: ImportMap, map2: ImportMap): ImportMap;

package/lib/model/remotes.d.ts

@@ -1,9 +1,9 @@
-import { FederationInfo } from './federation-info';
-export declare type Remote = FederationInfo & {
-    baseUrl: string;
-};
-export declare function addRemote(remoteName: string, remote: Remote): void;
-export declare function getRemoteNameByBaseUrl(baseUrl: string): string | undefined;
-export declare function isRemoteInitialized(baseUrl: string): boolean;
-export declare function getRemote(remoteName: string): Remote | undefined;
-export declare function hasRemote(remoteName: string): boolean;
+import { FederationInfo } from './federation-info';
+export type Remote = FederationInfo & {
+    baseUrl: string;
+};
+export declare function addRemote(remoteName: string, remote: Remote): void;
+export declare function getRemoteNameByBaseUrl(baseUrl: string): string | undefined;
+export declare function isRemoteInitialized(baseUrl: string): boolean;
+export declare function getRemote(remoteName: string): Remote | undefined;
+export declare function hasRemote(remoteName: string): boolean;

package/lib/utils/add-import-map.d.ts

@@ -1,2 +1,2 @@
-import { ImportMap } from '../model/import-map';
-export declare function appendImportMap(importMap: ImportMap): void;
+import { ImportMap } from '../model/import-map';
+export declare function appendImportMap(importMap: ImportMap): void;

package/lib/utils/path-utils.d.ts

@@ -1,2 +1,2 @@
-export declare function getDirectory(url: string): string;
-export declare function joinPaths(path1: string, path2: string): string;
+export declare function getDirectory(url: string): string;
+export declare function joinPaths(path1: string, path2: string): string;

package/package.json

@@ -1,15 +1,11 @@
 {
   "name": "@softarc/native-federation-runtime",
-  "version": "1.1.1",
+  "version": "2.0.0",
   "peerDependencies": {},
   "dependencies": {
     "tslib": "^2.3.0"
   },
-  "module": "fesm2015/softarc-native-federation-runtime.mjs",
-  "es2020": "fesm2020/softarc-native-federation-runtime.mjs",
-  "esm2020": "esm2020/softarc-native-federation-runtime.mjs",
-  "fesm2020": "fesm2020/softarc-native-federation-runtime.mjs",
-  "fesm2015": "fesm2015/softarc-native-federation-runtime.mjs",
+  "module": "fesm2022/softarc-native-federation-runtime.mjs",
   "typings": "index.d.ts",
   "exports": {
     "./package.json": {
@@ -17,11 +13,9 @@
     },
     ".": {
       "types": "./index.d.ts",
-      "esm2020": "./esm2020/softarc-native-federation-runtime.mjs",
-      "es2020": "./fesm2020/softarc-native-federation-runtime.mjs",
-      "es2015": "./fesm2015/softarc-native-federation-runtime.mjs",
-      "node": "./fesm2015/softarc-native-federation-runtime.mjs",
-      "default": "./fesm2020/softarc-native-federation-runtime.mjs"
+      "esm2022": "./esm2022/softarc-native-federation-runtime.mjs",
+      "esm": "./esm2022/softarc-native-federation-runtime.mjs",
+      "default": "./fesm2022/softarc-native-federation-runtime.mjs"
     }
   },
   "sideEffects": false