#Runtime Hooks

function beforeInit(args: BeforeInitOptions): BeforeInitOptions  type BeforeInitOptions ={  userOptions: UserOptions;  options: ModuleFederationRuntimeOptions;  origin: ModuleFederation;  shareInfo: ShareInfos; }  interface ModuleFederationRuntimeOptions {  id?: string;  name: string;  version?: string;  remotes: Array<Remote>;  shared: ShareInfos;  plugins: Array<ModuleFederationRuntimePlugin>;  inBrowser: boolean; }

function init(args: InitOptions): void  type InitOptions ={  options: ModuleFederationRuntimeOptions;  origin: ModuleFederation; }

async function beforeRequest(args: BeforeRequestOptions): Promise<BeforeRequestOptions>  type BeforeRequestOptions ={  id: string;  options: ModuleFederationRuntimeOptions;  origin: ModuleFederation; }

async function afterResolve(args: AfterResolveOptions): Promise<AfterResolveOptions>  type AfterResolveOptions ={  id: string;  pkgNameOrAlias: string;  expose: string;  remote: Remote;  options: ModuleFederationRuntimeOptions;  origin: ModuleFederation;  remoteInfo: RemoteInfo;  remoteSnapshot?: ModuleInfo; }

async function onLoad(args: OnLoadOptions): Promise<void>  type OnLoadOptions ={  id: string;  expose: string;  pkgNameOrAlias: string;  remote: Remote;  options: ModuleOptions;  origin: ModuleFederation;  exposeModule: any;  exposeModuleFactory: any;  moduleInstance: Module; }  type ModuleOptions = {  remoteInfo: RemoteInfo;  host: ModuleFederation; }  interface RemoteInfo {  name: string;  version?: string;  buildVersion?: string;  entry: string;  type: RemoteEntryType;  entryGlobalName: string;  shareScope: string; }

function handlePreloadModule(args: HandlePreloadModuleOptions): void  type HandlePreloadModuleOptions ={  id: string;  name: string;  remoteSnapshot: ModuleInfo;  preloadConfig: PreloadRemoteArgs; }

async function errorLoadRemote(args: ErrorLoadRemoteOptions): Promise<void | unknown>  type ErrorLoadRemoteOptions ={  id: string;  error: unknown;  from: 'build' | 'runtime';  origin: ModuleFederation; }

import { createInstance } from '@module-federation/enhanced/runtime'  import type { ModuleFederationRuntimePlugin } from '@module-federation/enhanced/runtime';  const fallbackPlugin: () => ModuleFederationRuntimePlugin =  function () {  return {  name: 'fallback-plugin',  errorLoadRemote(args) {  const fallback = 'fallback'  return fallback;  },  };  };   const mf = createInstance({  name: 'mf_host',  remotes: [  {  name: "remote",  alias: "app1",  entry: "http://localhost:2001/mf-manifest.json"  }  ],  plugins: [fallbackPlugin()] });  mf.loadRemote('app1/un-existed-module').then(mod=>{  expect(mod).toEqual('fallback'); })

async function beforeLoadShare(args: BeforeLoadShareOptions): Promise<BeforeLoadShareOptions>  type BeforeLoadShareOptions ={  pkgName: string;  shareInfo?: Shared;  shared: Options['shared'];  origin: ModuleFederation; }

function resolveShare(args: ResolveShareOptions): ResolveShareOptions  type ResolveShareOptions ={  shareScopeMap: ShareScopeMap;  scope: string;  pkgName: string;  version: string;  GlobalFederation: Federation;  resolver: () => Shared | undefined; }

import { createInstance, loadRemote } from '@module-federation/enhanced/runtime'  import type { ModuleFederationRuntimePlugin } from '@module-federation/enhanced/runtime';  const customSharedPlugin: () => ModuleFederationRuntimePlugin =  function () {  return {  name: 'custom-shared-plugin',  resolveShare(args) {  const { shareScopeMap, scope, pkgName, version, GlobalFederation } = args;   if (  pkgName !== 'react'  ) {  return args;  }   args.resolver = function () {  shareScopeMap[scope][pkgName][version] = window.React; // replace local share scope manually with desired module  return shareScopeMap[scope][pkgName][version];  };  return args;  },  };  };   const mf = createInstance({  name: 'mf_host',  shared: {  react: {  version: '17.0.0',  scope: 'default',  lib: () => React,  shareConfig: {  singleton: true,  requiredVersion: '^17.0.0',  },  },  },  plugins: [customSharedPlugin()] });  window.React = ()=> 'Desired Shared';  mf.loadShare("react").then((reactFactory)=>{  expect(reactFactory()).toEqual(window.React()); });

async function beforePreloadRemote(args: BeforePreloadRemoteOptions): BeforePreloadRemoteOptions  type BeforePreloadRemoteOptions ={  preloadOps: Array<PreloadRemoteArgs>;  options: Options;  origin: ModuleFederation; }

async function generatePreloadAssets(args: GeneratePreloadAssetsOptions): Promise<PreloadAssets>  type GeneratePreloadAssetsOptions ={  origin: ModuleFederation;  preloadOptions: PreloadOptions[number];  remote: Remote;  remoteInfo: RemoteInfo;  remoteSnapshot: ModuleInfo;  globalSnapshot: GlobalModuleInfo; }  interface PreloadAssets {  cssAssets: Array<string>;  jsAssetsWithoutEntry: Array<string>;  entryAssets: Array<EntryAssets>; }

function createScript(args: CreateScriptOptions): HTMLScriptElement | void  type CreateScriptOptions ={  url: string; }

import type { ModuleFederationRuntimePlugin } from '@module-federation/enhanced/runtime';  const changeScriptAttributePlugin: () => ModuleFederationRuntimePlugin =  function () {  return {  name: 'change-script-attribute',  createScript({ url }) {  if (url === testRemoteEntry) {  let script = document.createElement('script');  script.src = testRemoteEntry;  script.setAttribute('loader-hooks', 'isTrue');  script.setAttribute('crossorigin', 'anonymous');  return script;  }  }  };  };