@module-federation/webpack-bundler-runtime 0.0.0-next-20231220075820 → 0.0.0-next-20231220081137

package/project.json

@@ -1,73 +0,0 @@
-{
-  "name": "webpack-bundler-runtime",
-  "$schema": "../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "packages/webpack-bundler-runtime/src",
-  "projectType": "library",
-  "targets": {
-    "build": {
-      "executor": "@nx/rollup:rollup",
-      "outputs": ["{options.outputPath}"],
-      "options": {
-        "parallel": false,
-        "outputPath": "packages/webpack-bundler-runtime/dist",
-        "main": "packages/webpack-bundler-runtime/src/index.ts",
-        "tsConfig": "packages/webpack-bundler-runtime/tsconfig.lib.json",
-        "assets": [],
-        "project": "packages/webpack-bundler-runtime/package.json",
-        "compiler": "swc",
-        "format": ["cjs", "esm"],
-        "external": ["@module-federation/*"],
-        "buildableProjectDepsInPackageJsonType": "dependencies",
-        "updateBuildableProjectDepsInPackageJson": true,
-        "rollupConfig": "packages/webpack-bundler-runtime/rollup.config.js"
-      },
-      "dependsOn": [
-        {
-          "target": "build",
-          "dependencies": true
-        }
-      ]
-    },
-    "lint": {
-      "executor": "@nx/linter:eslint",
-      "outputs": ["{options.outputFile}"],
-      "options": {
-        "lintFilePatterns": [
-          "packages/webpack-bundler-runtime/**/*.ts",
-          "packages/webpack-bundler-runtime/package.json"
-        ]
-      }
-    },
-    "test": {
-      "executor": "@nx/jest:jest",
-      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
-      "options": {
-        "jestConfig": "packages/webpack-bundler-runtime/jest.config.js",
-        "passWithNoTests": true
-      },
-      "configurations": {
-        "ci": {
-          "ci": true,
-          "codeCoverage": true
-        }
-      }
-    },
-    "pre-release": {
-      "executor": "nx:run-commands",
-      "options": {
-        "parallel": false,
-        "commands": [
-          {
-            "command": "nx run webpack-bundler-runtime:test",
-            "forwardAllArgs": false
-          },
-          {
-            "command": "nx run webpack-bundler-runtime:build",
-            "forwardAllArgs": false
-          }
-        ]
-      }
-    }
-  },
-  "tags": ["package"]
-}

package/rollup.config.js

@@ -1,16 +0,0 @@
-const copy = require('rollup-plugin-copy');
-
-module.exports = (rollupConfig, projectOptions) => {
-  rollupConfig.plugins.push(
-    copy({
-      targets: [
-        {
-          src: 'packages/webpack-bundler-runtime/LICENSE',
-          dest: 'dist/packages/webpack-bundler-runtime',
-        },
-      ],
-    }),
-  );
-
-  return rollupConfig;
-};

package/src/consumes.ts

@@ -1,62 +0,0 @@
-import { ConsumesOptions } from './types';
-import { proxyShareScopeMap } from './proxyShareScopeMap';
-
-export function consumes(options: ConsumesOptions) {
-  const {
-    chunkId,
-    promises,
-    chunkMapping,
-    installedModules,
-    moduleToHandlerMapping,
-    webpackRequire,
-  } = options;
-  proxyShareScopeMap(webpackRequire);
-  if (webpackRequire.o(chunkMapping, chunkId)) {
-    chunkMapping[chunkId].forEach((id) => {
-      if (webpackRequire.o(installedModules, id)) {
-        return promises.push(installedModules[id] as Promise<any>);
-      }
-      const onFactory = (factory: () => any) => {
-        installedModules[id] = 0;
-        webpackRequire.m[id] = (module) => {
-          delete webpackRequire.c[id];
-          module.exports = factory();
-        };
-      };
-      const onError = (error: unknown) => {
-        delete installedModules[id];
-        webpackRequire.m[id] = (module) => {
-          delete webpackRequire.c[id];
-          throw error;
-        };
-      };
-      try {
-        const federationInstance = webpackRequire.federation.instance;
-        if (!federationInstance) {
-          throw new Error('Federation instance not found!');
-        }
-        const { shareKey, getter, shareInfo } = moduleToHandlerMapping[id];
-
-        const promise = federationInstance
-          .loadShare(shareKey, shareInfo)
-          .then((factory: any) => {
-            if (factory === false) {
-              return getter();
-            }
-            return factory;
-          });
-
-        if (promise.then) {
-          promises.push(
-            (installedModules[id] = promise.then(onFactory).catch(onError)),
-          );
-        } else {
-          // @ts-ignore maintain previous logic
-          onFactory(promise);
-        }
-      } catch (e) {
-        onError(e);
-      }
-    });
-  }
-}

package/src/index.ts

@@ -1,20 +0,0 @@
-import * as runtime from '@module-federation/runtime';
-import { Federation } from './types';
-import { remotes } from './remotes';
-import { consumes } from './consumes';
-import { initializeSharing } from './initializeSharing';
-import { installInitialConsumes } from './installInitialConsumes';
-
-const federation: Federation = {
-  runtime,
-  instance: undefined,
-  initOptions: undefined,
-  bundlerRuntime: {
-    remotes,
-    consumes,
-    I: initializeSharing,
-    S: {},
-    installInitialConsumes,
-  },
-};
-export default federation;

package/src/initializeSharing.ts

@@ -1,8 +0,0 @@
-import { WebpackRequire } from './types';
-
-export function initializeSharing(
-  shareScopeName: string,
-  webpackRequire: WebpackRequire,
-): Promise<boolean> | boolean {
-  return webpackRequire.federation.instance!.initializeSharing(shareScopeName);
-}

package/src/installInitialConsumes.ts

@@ -1,48 +0,0 @@
-import {
-  HandleInitialConsumesOptions,
-  InstallInitialConsumesOptions,
-} from './types';
-function handleInitialConsumes(options: HandleInitialConsumesOptions) {
-  const { moduleId, moduleToHandlerMapping, webpackRequire } = options;
-
-  const federationInstance = webpackRequire.federation.instance;
-  if (!federationInstance) {
-    throw new Error('Federation instance not found!');
-  }
-  const { shareKey, shareInfo } = moduleToHandlerMapping[moduleId];
-
-  if (!shareInfo.shareConfig.eager) {
-    throw new Error(
-      `Shared: "${shareKey}" cannot be loaded synchronously unless "eager:true" is set or async entry is enabled.`,
-    );
-  }
-  return federationInstance.loadShareSync(shareKey);
-}
-
-export function installInitialConsumes(options: InstallInitialConsumesOptions) {
-  const {
-    moduleToHandlerMapping,
-    webpackRequire,
-    installedModules,
-    initialConsumes,
-  } = options;
-
-  initialConsumes.forEach((id) => {
-    webpackRequire.m[id] = (module) => {
-      // Handle scenario when module is used synchronously
-      installedModules[id] = 0;
-      delete webpackRequire.c[id];
-      const factory = handleInitialConsumes({
-        moduleId: id,
-        moduleToHandlerMapping,
-        webpackRequire,
-      });
-      if (typeof factory !== 'function') {
-        throw new Error(
-          `Shared module is not available for eager consumption: ${id}`,
-        );
-      }
-      module.exports = factory();
-    };
-  });
-}

package/src/proxyShareScopeMap.ts

@@ -1,17 +0,0 @@
-import { WebpackRequire } from './types';
-
-export function proxyShareScopeMap(__webpack_require__: WebpackRequire) {
-  if (!__webpack_require__.S) {
-    return;
-  }
-  // @ts-ignore FIXME: ideal situation is import type from @module-federation/runtime/type ,but the compile will throw error
-  __webpack_require__.S = new Proxy(globalThis.__VMOK__.__SHARE__, {
-    get(target, prop: string, receiver) {
-      return globalThis.__VMOK__.__SHARE__[prop];
-    },
-    set(target, prop: string, value) {
-      globalThis.__VMOK__.__SHARE__[prop] = value;
-      return true;
-    },
-  });
-}

package/src/remotes.ts

@@ -1,113 +0,0 @@
-import type { RemoteEntryExports } from './types';
-import { RemotesOptions } from './types';
-
-export function remotes(options: RemotesOptions) {
-  const {
-    chunkId,
-    promises,
-    chunkMapping,
-    idToExternalAndNameMapping,
-    webpackRequire,
-  } = options;
-
-  if (webpackRequire.o(chunkMapping, chunkId)) {
-    chunkMapping[chunkId].forEach((id) => {
-      let getScope = webpackRequire.R;
-      if (!getScope) {
-        getScope = [];
-      }
-      const data = idToExternalAndNameMapping[id];
-      // @ts-ignore seems not work
-      if (getScope.indexOf(data) >= 0) {
-        return;
-      }
-      // @ts-ignore seems not work
-      getScope.push(data);
-      if (data.p) {
-        return promises.push(data.p as Promise<any>);
-      }
-      const onError = (error?: Error) => {
-        if (!error) {
-          error = new Error('Container missing');
-        }
-        if (typeof error.message === 'string') {
-          error.message += `\nwhile loading "${data[1]}" from ${data[2]}`;
-        }
-        webpackRequire.m[id] = () => {
-          throw error;
-        };
-        data.p = 0;
-      };
-      const handleFunction = (
-        fn: (...args: any[]) => any,
-        arg1: any,
-        arg2: any,
-        d: any,
-        next: (...args: any[]) => any,
-        first: 1 | 0,
-      ) => {
-        try {
-          const promise = fn(arg1, arg2);
-          if (promise && promise.then) {
-            const p = promise.then((result: any) => next(result, d), onError);
-            if (first) {
-              promises.push((data.p = p));
-            } else {
-              return p;
-            }
-          } else {
-            return next(promise, d, first);
-          }
-        } catch (error) {
-          onError(error as Error);
-        }
-      };
-      const onExternal = (
-        external: (...args: any[]) => any,
-        _: any,
-        first: 1 | 0,
-      ) =>
-        external
-          ? handleFunction(
-              webpackRequire.I,
-              data[0],
-              0,
-              external,
-              onInitialized,
-              first,
-            )
-          : onError();
-
-      // eslint-disable-next-line no-var
-      var onInitialized = (
-        _: any,
-        external: RemoteEntryExports,
-        first: 1 | 0,
-      ) => handleFunction(external.get, data[1], getScope, 0, onFactory, first);
-      const useRuntimeLoad = ['script'].includes(data[3]) && data[4];
-      // eslint-disable-next-line no-var
-      var onFactory = (factory: () => any) => {
-        data.p = 1;
-        webpackRequire.m[id] = (module) => {
-          module.exports = factory();
-        };
-      };
-      const onRemoteLoaded = () => {
-        try {
-          const remoteModuleName = data[4] + data[1].slice(1);
-          return webpackRequire.federation.instance!.loadRemote(
-            remoteModuleName,
-            { loadFactory: false },
-          );
-        } catch (error) {
-          onError(error as Error);
-        }
-      };
-      if (useRuntimeLoad) {
-        handleFunction(onRemoteLoaded, data[2], 0, 0, onFactory, 1);
-      } else {
-        handleFunction(webpackRequire, data[2], 0, 0, onExternal, 1);
-      }
-    });
-  }
-}

package/src/types.ts

@@ -1,115 +0,0 @@
-import * as runtime from '@module-federation/runtime';
-import { initializeSharing } from './initializeSharing';
-
-// FIXME: ideal situation => import { GlobalShareScope,UserOptions } from '@module-federation/runtime/type'
-type ExcludeUndefined<T> = T extends undefined ? never : T;
-type NonUndefined<T = Shared> = ExcludeUndefined<T>;
-
-type InitOptions = Parameters<typeof runtime.init>[0];
-type Shared = InitOptions['shared'];
-
-type SharedConfig = NonUndefined<NonUndefined[string]['shareConfig']>;
-
-type ModuleCache = runtime.FederationHost['moduleCache'];
-type InferModule<T> = T extends Map<string, infer U> ? U : never;
-type InferredModule = InferModule<ModuleCache>;
-export type RemoteEntryExports = NonUndefined<
-  InferredModule['remoteEntryExports']
->;
-
-type ExtractInitParameters<T> = T extends {
-  init: (shareScope: infer U, ...args: any[]) => void;
-}
-  ? U
-  : never;
-
-type InferredShareScope = ExtractInitParameters<RemoteEntryExports>;
-type InferredGlobalShareScope = {
-  [scope: string]: InferredShareScope;
-};
-
-// shareScope, name, externalModuleId, externalType, remoteName
-type IdToExternalAndNameMappingItem = [
-  string,
-  string,
-  string | number,
-  string,
-  string,
-];
-
-interface IdToExternalAndNameMappingItemWithPromise
-  extends IdToExternalAndNameMappingItem {
-  p?: Promise<any> | number;
-}
-
-export interface WebpackRequire {
-  (moduleId: string | number): any;
-  o: (obj: Record<string, any>, key: string | number) => boolean;
-  R: Array<string | number>;
-  m: Record<string, (mod: any) => any>;
-  c: Record<string, any>;
-  I: typeof initializeSharing;
-  S?: InferredGlobalShareScope;
-  federation: Federation;
-}
-
-interface ShareInfo {
-  shareConfig: SharedConfig;
-  scope: Array<string>;
-}
-
-interface ModuleToHandlerMappingItem {
-  // handler: (shareInfo: ShareInfo, type?: 'syn' | 'async') => Promise<any>;
-  getter: () => Promise<any>;
-  shareInfo: ShareInfo;
-  shareKey: string;
-}
-
-export interface RemotesOptions {
-  chunkId: string | number;
-  promises: Promise<any>[];
-  chunkMapping: Record<string, Array<string | number>>;
-  idToExternalAndNameMapping: Record<
-    string,
-    IdToExternalAndNameMappingItemWithPromise
-  >;
-  webpackRequire: WebpackRequire;
-}
-
-export interface HandleInitialConsumesOptions {
-  moduleId: string | number;
-  moduleToHandlerMapping: Record<string, ModuleToHandlerMappingItem>;
-  webpackRequire: WebpackRequire;
-}
-export interface InstallInitialConsumesOptions {
-  moduleToHandlerMapping: Record<string, ModuleToHandlerMappingItem>;
-  webpackRequire: WebpackRequire;
-  installedModules: Record<string, Promise<any> | 0>;
-  initialConsumes: Array<string | number>;
-}
-
-export interface ConsumesOptions {
-  chunkId: string | number;
-  promises: Promise<any>[];
-  chunkMapping: Record<string, Array<string | number>>;
-  installedModules: Record<string, Promise<any> | 0>;
-  moduleToHandlerMapping: Record<string, ModuleToHandlerMappingItem>;
-  webpackRequire: WebpackRequire;
-}
-
-export interface Federation {
-  runtime?: typeof runtime;
-  instance?: runtime.FederationHost;
-  initOptions?: InitOptions;
-  installInitialConsumes?: (options: InstallInitialConsumesOptions) => any;
-  bundlerRuntime?: {
-    remotes: (options: RemotesOptions) => void;
-    consumes: (options: ConsumesOptions) => void;
-    I: (
-      name: string,
-      webpackRequire: WebpackRequire,
-    ) => Promise<boolean> | boolean;
-    S: InferredGlobalShareScope;
-    installInitialConsumes: (options: InstallInitialConsumesOptions) => any;
-  };
-}

package/tsconfig.json

@@ -1,28 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "module": "commonjs",
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "noImplicitOverride": true,
-    "noPropertyAccessFromIndexSignature": true,
-    "noFallthroughCasesInSwitch": true,
-    "moduleResolution": "node",
-    "resolveJsonModule": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "skipDefaultLibCheck": true,
-    "declaration": true,
-    "noImplicitReturns": false
-  },
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ]
-}

package/tsconfig.lib.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "declaration": true,
-    "types": ["node"]
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
-}

package/tsconfig.spec.json

@@ -1,14 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "module": "commonjs",
-    "types": ["jest", "node"]
-  },
-  "include": [
-    "jest.config.ts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.d.ts"
-  ]
-}