@module-federation/sdk 0.0.0-next-20231219090402 → 0.0.0-next-20231219093556

package/src/normalize-webpack-path.ts

@@ -0,0 +1,33 @@
+import type webpack from 'webpack';
+import path from 'path';
+export function getWebpackPath(compiler: webpack.Compiler): string {
+  try {
+    // @ts-ignore just throw err
+    compiler.webpack();
+    return '';
+  } catch (err) {
+    const trace = (err as Error).stack?.split('\n') || [];
+    const webpackErrLocation =
+      trace.find((item) => item.includes('at webpack')) || '';
+    const webpackLocationWithDetail = webpackErrLocation
+      .replace(/[^\(\)]+/, '')
+      .slice(1, -1);
+    const webpackPath = webpackLocationWithDetail.split(':').slice(0, -2)[0];
+    return require.resolve('webpack', { paths: [webpackPath] });
+  }
+}
+
+export const normalizeWebpackPath = (fullPath: string): string => {
+  if (fullPath === 'webpack') {
+    return process.env['FEDERATION_WEBPACK_PATH'] || fullPath;
+  }
+
+  if (process.env['FEDERATION_WEBPACK_PATH']) {
+    return path.resolve(
+      process.env['FEDERATION_WEBPACK_PATH'],
+      fullPath.replace('webpack', '../../'),
+    );
+  }
+
+  return fullPath;
+};

package/src/types/common.ts

@@ -0,0 +1,18 @@
+export interface RemoteWithEntry {
+  name: string;
+  entry: string;
+}
+
+export interface RemoteWithVersion {
+  name: string;
+  version: string;
+}
+
+export type RemoteEntryInfo = RemoteWithEntry | RemoteWithVersion;
+export type Module = any;
+
+declare namespace NodeJS {
+  interface ProcessEnv {
+    FEDERATION_WEBPACK_PATH?: string;
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,4 @@
+export * from './common';
+export * from './manifest';
+export * from './stats';
+export * from './snapshot';

package/src/types/manifest.ts

@@ -0,0 +1,44 @@
+import {
+  StatsMetaData,
+  StatsAssets,
+  StatsExpose,
+  BasicStatsMetaData,
+} from './stats';
+import { RemoteWithEntry, RemoteWithVersion } from './common';
+
+export interface ManifestShared {
+  id: string;
+  name: string;
+  version: string;
+  singleton: boolean;
+  requiredVersion: string;
+  hash: string;
+  assets: StatsAssets;
+}
+
+export interface ManifestRemoteCommonInfo {
+  federationContainerName: string;
+  moduleName: string;
+  alias: string;
+}
+
+export type ManifestRemote<T = ManifestRemoteCommonInfo> =
+  | (Omit<RemoteWithEntry, 'name'> & T)
+  | (Omit<RemoteWithVersion, 'name'> & T);
+
+export type ManifestExpose = Pick<
+  StatsExpose,
+  'assets' | 'id' | 'name' | 'path'
+>;
+
+export interface Manifest<
+  T = BasicStatsMetaData,
+  K = ManifestRemoteCommonInfo,
+> {
+  id: string;
+  name: string;
+  metaData: StatsMetaData<T>;
+  shared: ManifestShared[];
+  remotes: ManifestRemote<K>[];
+  exposes: ManifestExpose[];
+}

package/src/types/snapshot.ts

@@ -0,0 +1,87 @@
+import { RemoteEntryType, StatsAssets } from './stats';
+
+interface BasicModuleInfo {
+  dev?: {
+    version?: string;
+    remotes?: { [nameWithType: string]: string };
+  };
+  version: string;
+  buildVersion: string;
+  remoteTypes: string;
+  remotesInfo: Record<string, { matchedVersion: string }>;
+  shared: Array<{
+    sharedName: string;
+    assets: StatsAssets;
+  }>;
+}
+
+export interface BasicProviderModuleInfo extends BasicModuleInfo {
+  remoteEntry: string;
+  remoteEntryType: RemoteEntryType;
+  remoteManifest?: string;
+  globalName: string;
+  modules: Array<{
+    moduleName: string;
+    modulePath?: string;
+    assets: StatsAssets;
+  }>;
+  prefetchEntry?: string;
+  prefetchEntryType?: RemoteEntryType;
+}
+
+interface BasicProviderModuleInfoWithPublicPath
+  extends BasicProviderModuleInfo {
+  publicPath: string;
+}
+
+interface BasicProviderModuleInfoWithGetPublicPath
+  extends BasicProviderModuleInfo {
+  getPublicPath: string;
+}
+
+export interface ManifestProvider {
+  remoteEntry: string;
+  version?: string;
+}
+
+export interface PureEntryProvider extends ManifestProvider {
+  globalName: string;
+}
+
+interface BasicConsumerModuleInfo extends BasicModuleInfo {
+  consumerList: Array<string>;
+}
+
+export interface ConsumerModuleInfoWithPublicPath
+  extends BasicConsumerModuleInfo,
+    BasicProviderModuleInfo {
+  publicPath: string;
+}
+
+interface ConsumerModuleInfoWithGetPublicPath
+  extends BasicConsumerModuleInfo,
+    BasicProviderModuleInfo {
+  getPublicPath: string;
+}
+
+export type PureConsumerModuleInfo = Omit<
+  BasicConsumerModuleInfo,
+  'remoteTypes'
+>;
+
+export type ConsumerModuleInfo =
+  | ConsumerModuleInfoWithPublicPath
+  | ConsumerModuleInfoWithGetPublicPath;
+
+export type ProviderModuleInfo =
+  | BasicProviderModuleInfoWithPublicPath
+  | BasicProviderModuleInfoWithGetPublicPath;
+
+export type ModuleInfo =
+  | ConsumerModuleInfo
+  | PureConsumerModuleInfo
+  | ProviderModuleInfo;
+
+export type GlobalModuleInfo = {
+  [key: string]: ModuleInfo | ManifestProvider | PureEntryProvider | undefined;
+};

package/src/types/stats.ts

@@ -0,0 +1,101 @@
+import type { RemoteWithEntry, RemoteWithVersion } from './common';
+
+export type RemoteEntryType = 'esm' | 'global';
+
+interface ResourceInfo {
+  path: string;
+  name: string;
+  type: RemoteEntryType;
+}
+
+export interface StatsBuildInfo {
+  buildVersion: string;
+  buildName: string;
+}
+
+export interface BasicStatsMetaData {
+  name: string;
+  globalName: string;
+  buildInfo: StatsBuildInfo;
+  remoteEntry: ResourceInfo;
+  prefetchEntry: ResourceInfo;
+  types: Omit<ResourceInfo, 'type'>;
+}
+
+type StatsMetaDataWithGetPublicPath<T = BasicStatsMetaData> = T & {
+  getPublicPath: string;
+};
+
+type StatsMetaDataWithPublicPath<T = BasicStatsMetaData> = T & {
+  publicPath: string;
+};
+
+export type StatsMetaData<T = BasicStatsMetaData> =
+  | StatsMetaDataWithGetPublicPath<T>
+  | StatsMetaDataWithPublicPath<T>;
+
+export interface StatsAssets {
+  js: StatsAssetsInfo;
+  css: StatsAssetsInfo;
+}
+
+interface StatsAssetsInfo {
+  sync: string[];
+  async: string[];
+}
+
+export interface StatsShared {
+  id: string;
+  name: string;
+  version: string;
+  singleton: boolean;
+  requiredVersion: string;
+  hash: string;
+  assets: StatsAssets;
+  deps: string[];
+  usedIn: string[];
+}
+// extends Omit<RemoteEntryInfo, 'name'>
+export interface StatsRemoteVal {
+  moduleName: string;
+  federationContainerName: string;
+  consumingFederationContainerName: string;
+  alias: string;
+  usedIn: string[];
+}
+
+export type StatsRemoteWithEntry<T = StatsRemoteVal> = T &
+  Omit<RemoteWithEntry, 'name'>;
+export type StatsRemoteWithVersion<T = StatsRemoteVal> = T &
+  Omit<RemoteWithVersion, 'name'>;
+
+export type StatsRemote<T = StatsRemoteVal> =
+  | StatsRemoteWithEntry<T>
+  | StatsRemoteWithVersion<T>;
+
+export interface StatsModuleInfo {
+  name: string;
+  file: string;
+}
+
+export interface ManifestModuleInfos {
+  [exposeModuleName: string]: StatsModuleInfo;
+}
+
+export interface StatsExpose {
+  id: string;
+  name: string;
+  path?: string; // 对线上已有数据兼容过渡至 2023-05-26
+  file: string;
+  requires: string[];
+  assets: StatsAssets;
+}
+
+export interface Stats<T = BasicStatsMetaData, K = StatsRemoteVal> {
+  id: string;
+  name: string;
+  metaData: StatsMetaData<T>;
+  shared: StatsShared[];
+  remotes: StatsRemote<K>[];
+  exposes: StatsExpose[];
+}

package/src/utils.ts

@@ -0,0 +1,213 @@
+import { RemoteEntryInfo, ModuleInfo } from './types';
+import {
+  NameTransformMap,
+  NameTransformSymbol,
+  EncodedNameTransformMap,
+  SEPARATOR,
+  MANIFEST_EXT,
+} from './constant';
+import { Logger } from './logger';
+import { getProcessEnv } from './env';
+
+const LOG_CATEGORY = '[ Federation Runtime ]';
+
+// entry: name:version   version : 1.0.0 | ^1.2.3
+// entry: name:entry  entry:  https://localhost:9000/federation-manifest.json
+const parseEntry = (str: string, devVerOrUrl?: string): RemoteEntryInfo => {
+  const strSplit = str.split(SEPARATOR);
+  const devVersionOrUrl =
+    getProcessEnv()['NODE_ENV'] === 'development' && devVerOrUrl;
+  const defaultVersion = '*';
+  const isEntry = (s: string) =>
+    s.startsWith('http') || s.endsWith(MANIFEST_EXT);
+
+  // Check if the string starts with a type
+  if (strSplit.length >= 2) {
+    const [name, ...versionOrEntryArr] = strSplit;
+    const versionOrEntry = devVersionOrUrl || versionOrEntryArr.join(SEPARATOR);
+    if (isEntry(versionOrEntry)) {
+      return {
+        name,
+        entry: versionOrEntry,
+      };
+    } else {
+      // Apply version rule
+      // devVersionOrUrl => inputVersion => defaultVersion
+      return {
+        name,
+        version: versionOrEntry || defaultVersion,
+      };
+    }
+  } else if (strSplit.length === 1) {
+    const [name] = strSplit;
+    if (devVersionOrUrl && isEntry(devVersionOrUrl)) {
+      return {
+        name,
+        entry: devVersionOrUrl,
+      };
+    }
+    return {
+      name,
+      version: devVersionOrUrl || defaultVersion,
+    };
+  } else {
+    throw `Invalid entry value: ${str}`;
+  }
+};
+
+declare global {
+  // eslint-disable-next-line no-var
+  var FEDERATION_DEBUG: string | undefined;
+}
+
+const logger = new Logger();
+
+const composeKeyWithSeparator = /* @__PURE__ */ function (
+  ...args: (string | undefined)[]
+): string {
+  if (!args.length) {
+    return '';
+  }
+
+  return args.reduce((sum, cur) => {
+    if (!cur) {
+      return sum;
+    }
+    if (!sum) {
+      return cur;
+    }
+
+    return `${sum}${SEPARATOR}${cur}`;
+  }, '') as string;
+};
+
+const encodeName = /* @__PURE__ */ function (
+  name: string,
+  prefix = '',
+  withExt = false,
+): string {
+  try {
+    const ext = withExt ? '.js' : '';
+    return `${prefix}${name
+      .replace(
+        new RegExp(`${NameTransformSymbol.AT}`, 'g'),
+        NameTransformMap[NameTransformSymbol.AT],
+      )
+      .replace(
+        new RegExp(`${NameTransformSymbol.HYPHEN}`, 'g'),
+        NameTransformMap[NameTransformSymbol.HYPHEN],
+      )
+      .replace(
+        new RegExp(`${NameTransformSymbol.SLASH}`, 'g'),
+        NameTransformMap[NameTransformSymbol.SLASH],
+      )}${ext}`;
+  } catch (err) {
+    throw err;
+  }
+};
+
+const decodeName = /* @__PURE__ */ function (
+  name: string,
+  prefix?: string,
+  withExt?: boolean,
+): string {
+  try {
+    let decodedName = name;
+    if (prefix) {
+      decodedName = decodedName.replace(new RegExp(prefix, 'g'), '');
+    }
+    decodedName = decodedName
+      .replace(
+        new RegExp(`${NameTransformMap[NameTransformSymbol.AT]}`, 'g'),
+        EncodedNameTransformMap[NameTransformMap[NameTransformSymbol.AT]],
+      )
+      .replace(
+        new RegExp(`${NameTransformMap[NameTransformSymbol.SLASH]}`, 'g'),
+        EncodedNameTransformMap[NameTransformMap[NameTransformSymbol.SLASH]],
+      )
+      .replace(
+        new RegExp(`${NameTransformMap[NameTransformSymbol.HYPHEN]}`, 'g'),
+        EncodedNameTransformMap[NameTransformMap[NameTransformSymbol.HYPHEN]],
+      );
+    if (withExt) {
+      decodedName = decodedName.replace('.js', '');
+    }
+    return decodedName;
+  } catch (err) {
+    throw err;
+  }
+};
+
+const generateExposeFilename = /* @__PURE__ */ (
+  exposeName: string,
+  withExt: boolean,
+): string => {
+  if (!exposeName) {
+    return '';
+  }
+
+  let expose = exposeName;
+  if (expose === '.') {
+    expose = 'default_export';
+  }
+  if (expose.startsWith('./')) {
+    expose = expose.replace('./', '');
+  }
+
+  return encodeName(expose, '__federation_expose_', withExt);
+};
+
+const generateShareFilename = /* @__PURE__ */ (
+  pkgName: string,
+  withExt: boolean,
+): string => {
+  if (!pkgName) {
+    return '';
+  }
+  return encodeName(pkgName, '__federation_shared_', withExt);
+};
+
+const getResourceUrl = (module: ModuleInfo, sourceUrl: string): string => {
+  if ('getPublicPath' in module) {
+    const publicPath = new Function(module.getPublicPath)();
+    return `${publicPath}${sourceUrl}`;
+  } else if ('publicPath' in module) {
+    return `${module.publicPath}${sourceUrl}`;
+  } else {
+    console.warn(
+      'Can not get resource url, if in debug mode, please ignore',
+      module,
+      sourceUrl,
+    );
+    return '';
+  }
+};
+
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+const assert = (condition: any, msg: string): asserts condition => {
+  if (!condition) {
+    error(msg);
+  }
+};
+
+const error = (msg: string | Error | unknown): never => {
+  throw new Error(`${LOG_CATEGORY}: ${msg}`);
+};
+
+const warn = (msg: Parameters<typeof console.warn>[0]): void => {
+  console.warn(`${LOG_CATEGORY}: ${msg}`);
+};
+
+export {
+  parseEntry,
+  logger,
+  decodeName,
+  encodeName,
+  composeKeyWithSeparator,
+  generateExposeFilename,
+  generateShareFilename,
+  getResourceUrl,
+  assert,
+  error,
+  warn,
+};

package/tsconfig.json

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

package/tsconfig.lib.json

@@ -0,0 +1,10 @@
+{
+  "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

@@ -0,0 +1,14 @@
+{
+  "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"
+  ]
+}

package/index.cjs.default.js

@@ -1 +0,0 @@
-exports._default = require('./index.cjs.js').default;

package/index.cjs.mjs

@@ -1,2 +0,0 @@
-export * from './index.cjs.js';
-export { _default as default } from './index.cjs.default.js';

package/normalize-webpack-path.cjs.default.js

@@ -1 +0,0 @@
-exports._default = require('./normalize-webpack-path.cjs.js').default;

package/normalize-webpack-path.cjs.mjs

@@ -1,2 +0,0 @@
-export * from './normalize-webpack-path.cjs.js';
-export { _default as default } from './normalize-webpack-path.cjs.default.js';