@alauda-fe/dynamic-plugin-sdk-rspack 0.0.1-alpha.1

package/README.md

@@ -0,0 +1,7 @@
+# dynamic-plugin-sdk-rspack
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build dynamic-plugin-sdk-rspack` to build the library.

package/index.js

@@ -0,0 +1,218 @@
+// libs/dynamic-plugin-sdk-rspack/src/lib/mfe-config-utils.ts
+var isCoreModules = (packageName) => {
+  const coreModules = [
+    "rxjs",
+    "zone.js",
+    "tslib",
+    "lodash-es",
+    "ramda",
+    "dayjs",
+    "pluralize",
+    "dompurify"
+  ];
+  if (coreModules.includes(packageName)) {
+    return true;
+  }
+  return packageName === "@alauda-fe/dynamic-plugin-sdk" || packageName.startsWith("@alauda/") || packageName.startsWith("@angular/") || packageName === "rxjs/operators" || // Explicit operators path
+  packageName.startsWith("rxjs/") || packageName.startsWith("dayjs/");
+};
+var isCommonjsModules = (packageName) => {
+  return packageName === "lottie-web" || packageName === "xterm" || packageName.startsWith("xterm-addon-");
+};
+var isStandaloneModules = (packageName) => {
+  return packageName === "@alauda-fe/plugin-sdk/remote";
+};
+var mfe_config_utils_default = {
+  shared: (packageName, config) => {
+    if (packageName && !isStandaloneModules(packageName) && (isCoreModules(packageName) || isCommonjsModules(packageName))) {
+      return { ...config, singleton: true, strictVersion: false };
+    }
+    return false;
+  }
+};
+
+// libs/dynamic-plugin-sdk-rspack/src/lib/with-alauda-console.ts
+function loadEsmModule(modulePath) {
+  return new Function("modulePath", `return import(modulePath);`)(modulePath);
+}
+async function loadModule(path) {
+  const module = await loadEsmModule(path);
+  return module.default || module;
+}
+var with_alauda_console_default = async (options) => {
+  const customWebpack = await loadModule("@alauda/custom-webpack");
+  return (config) => {
+    config.resolve ??= {};
+    config.resolve.alias ??= {};
+    config.plugins ??= [];
+    return customWebpack(config, options);
+  };
+};
+
+// libs/dynamic-plugin-sdk-rspack/src/lib/with-base-config.ts
+import { merge } from "rspack-merge";
+var with_base_config_default = () => (config) => {
+  return merge(config, {
+    module: {
+      rules: [
+        {
+          test: /\.css$/i,
+          resourceQuery: { not: [/ngGlobalStyle/, /ngResource/] },
+          issuer: /\.[jt]sx?$|\.[cm]js$/,
+          use: [
+            "style-loader",
+            {
+              loader: "css-loader",
+              options: {
+                // https://github.com/webpack/webpack-dev-server/issues/1815#issuecomment-1181720815
+                url: false
+              }
+            }
+          ]
+        }
+      ]
+    },
+    ignoreWarnings: [
+      {
+        module: /monaco-(editor|yaml)/
+      },
+      /Failed to parse source map from/
+    ],
+    resolve: {
+      alias: {
+        dayjs: "dayjs/esm"
+      }
+    }
+  });
+};
+
+// libs/dynamic-plugin-sdk-rspack/src/lib/with-host-mfe-config.ts
+import { withModuleFederation } from "@nx/module-federation/rspack";
+import { merge as merge2 } from "rspack-merge";
+var proxy = "http://localhost:8080/";
+function createRemoteProxy({ disableDevPluginProxy = false } = {}) {
+  const remoteProxy = [
+    {
+      context: ["/clusters-rewrite/"],
+      target: proxy,
+      timeout: 5e3,
+      secure: false,
+      changeOrigin: true
+    },
+    {
+      context: ["/console-assets/"],
+      target: proxy,
+      timeout: 5e3,
+      secure: false,
+      changeOrigin: true
+    },
+    {
+      context: ["/console-i18n/"],
+      target: proxy,
+      timeout: 5e3,
+      secure: false,
+      changeOrigin: true
+    }
+  ];
+  if (!disableDevPluginProxy) {
+    remoteProxy.unshift({
+      context: ["/dev-plugin/"],
+      target: "http://localhost:5000/",
+      timeout: 5e3,
+      secure: false,
+      changeOrigin: true,
+      pathRewrite: {
+        "/dev-plugin/": "/"
+      }
+    });
+  }
+  return remoteProxy;
+}
+var with_host_mfe_config_default = async (mfeConfig, overrideConfig, options = {}) => {
+  const mfe = await withModuleFederation(mfeConfig, overrideConfig);
+  const { disableDevPluginProxy = false } = options;
+  return (config) => merge2(mfe(config, { context: config.context }), {
+    devServer: {
+      proxy: createRemoteProxy({ disableDevPluginProxy })
+    }
+  });
+};
+
+// libs/dynamic-plugin-sdk-rspack/src/lib/with-monaco-editor.ts
+import MonacoWebpackPlugin from "monaco-editor-webpack-plugin";
+import { merge as merge3 } from "rspack-merge";
+var with_monaco_editor_default = () => (config) => {
+  return merge3(config, {
+    plugins: [
+      new MonacoWebpackPlugin({
+        globalAPI: true,
+        languages: ["yaml"],
+        customLanguages: [
+          {
+            label: "yaml",
+            entry: "monaco-yaml",
+            worker: {
+              id: "monaco-yaml/yamlWorker",
+              entry: "monaco-yaml/yaml.worker"
+            }
+          }
+        ]
+      })
+    ]
+  });
+};
+
+// libs/dynamic-plugin-sdk-rspack/src/lib/with-remote-mfe-config.ts
+import { execSync } from "child_process";
+import { withModuleFederation as withModuleFederation2 } from "@nx/module-federation/rspack";
+import { merge as merge4 } from "rspack-merge";
+var generateName = (name) => {
+  const commitID = execSync("git rev-parse --short HEAD").toString().trim();
+  return `${name}__${commitID}`;
+};
+var with_remote_mfe_config_default = async (mfeConfig, overrideConfig) => {
+  const mfe = await withModuleFederation2(mfeConfig, overrideConfig);
+  return (config) => {
+    return merge4(mfe(config, { context: config.context }), {
+      output: { uniqueName: generateName(mfeConfig.name) },
+      devServer: {
+        headers: {
+          "Access-Control-Allow-Origin": "*"
+        }
+      }
+    });
+  };
+};
+
+// libs/dynamic-plugin-sdk-rspack/src/lib/with-yaml-loader.ts
+import { merge as merge5 } from "rspack-merge";
+var with_yaml_loader_default = () => (config) => {
+  return merge5(config, {
+    module: {
+      rules: [
+        {
+          test: /\.ya?ml$/,
+          use: "yaml-loader"
+        }
+      ]
+    }
+  });
+};
+
+// libs/dynamic-plugin-sdk-rspack/src/lib/utils.ts
+var compose = (...fns) => (v) => fns.reduceRight((acc, curr) => curr(acc), v);
+var log = (v, ...messages) => {
+  console.log(v, ...messages);
+  return v;
+};
+export {
+  compose,
+  log,
+  mfe_config_utils_default as mfeConfigUtils,
+  with_alauda_console_default as withAlaudaConsole,
+  with_base_config_default as withBaseConfig,
+  with_host_mfe_config_default as withHostMfeConfig,
+  with_monaco_editor_default as withMonacoEditor,
+  with_remote_mfe_config_default as withRemoteMfeConfig,
+  with_yaml_loader_default as withYamlLoader
+};

package/lib/i18n-merge.js

@@ -0,0 +1,177 @@
+/* eslint-disable jsdoc/require-returns, jsdoc/require-returns-description */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * @param {string[]} argv
+ */
+function parseArgs(argv) {
+  let configPath = 'i18n.config.js';
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+
+    if (arg === '-c' || arg === '--config') {
+      const next = argv[i + 1];
+      if (!next || next.startsWith('-')) {
+        throw new Error('Missing value for -c/--config');
+      }
+      configPath = next;
+      i += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--config=')) {
+      configPath = arg.slice('--config='.length);
+      continue;
+    }
+
+    if (arg === '-h' || arg === '--help') {
+      console.log('Usage: node lib/i18n-merge.js -c i18n.config.js');
+      // eslint-disable-next-line n/no-process-exit
+      process.exit(0);
+    }
+  }
+
+  return configPath;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {value is object}
+ */
+function isPlainObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value);
+}
+
+/**
+ * @param {object} source
+ */
+function removeEmptyKeys(source) {
+  const result = {};
+
+  Object.keys(source).forEach(key => {
+    if (key.trim().length === 0) {
+      return;
+    }
+
+    const value = source[key];
+    if (isPlainObject(value)) {
+      result[key] = removeEmptyKeys(value);
+      return;
+    }
+
+    result[key] = value;
+  });
+
+  return result;
+}
+
+/**
+ * @param {object} target
+ * @param {object} source
+ */
+function deepMerge(target, source) {
+  const result = { ...target };
+
+  Object.keys(source).forEach(key => {
+    const sourceValue = source[key];
+    const targetValue = result[key];
+
+    if (isPlainObject(targetValue) && isPlainObject(sourceValue)) {
+      result[key] = deepMerge(targetValue, sourceValue);
+      return;
+    }
+
+    result[key] = sourceValue;
+  });
+
+  return result;
+}
+
+/**
+ * @template T
+ * @param {string} filePath
+ * @returns {T}
+ */
+function readJson(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  return JSON.parse(content);
+}
+
+/**
+ * @param {string} cwd
+ * @param {string} configDir
+ * @param {string} inputPath
+ */
+function resolveInputFile(cwd, configDir, inputPath) {
+  if (path.isAbsolute(inputPath)) {
+    return inputPath;
+  }
+
+  const fromCwd = path.resolve(cwd, inputPath);
+  if (fs.existsSync(fromCwd)) {
+    return fromCwd;
+  }
+
+  return path.resolve(configDir, inputPath);
+}
+
+async function run() {
+  const cwd = process.cwd();
+  const configArg = parseArgs(process.argv.slice(2));
+  const configPath = path.resolve(cwd, configArg);
+
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`Config file not found: ${configPath}`);
+  }
+
+  const config = await import(configPath);
+  const inputs = config?.input;
+  const output = config?.output;
+
+  if (!Array.isArray(inputs) || inputs.length === 0) {
+    throw new Error('Config "input" must be a non-empty array');
+  }
+
+  if (typeof output !== 'string' || output.length === 0) {
+    throw new Error('Config "output" must be a non-empty string');
+  }
+
+  const configDir = path.dirname(configPath);
+  const merged = inputs.reduce((acc, item) => {
+    if (typeof item !== 'string' || item.length === 0) {
+      throw new Error('Each "input" item must be a non-empty string');
+    }
+
+    const inputFile = resolveInputFile(cwd, configDir, item);
+    if (!fs.existsSync(inputFile)) {
+      throw new Error(`Input file not found: ${inputFile}`);
+    }
+
+    const json = readJson(inputFile);
+    if (!isPlainObject(json)) {
+      throw new Error(`Input file must contain a JSON object: ${inputFile}`);
+    }
+
+    return deepMerge(acc, removeEmptyKeys(json));
+  }, {});
+
+  const outputFile = path.isAbsolute(output)
+    ? output
+    : path.resolve(cwd, output);
+
+  fs.mkdirSync(path.dirname(outputFile), { recursive: true });
+  fs.writeFileSync(outputFile, `${JSON.stringify(merged, null, 2)}\n`, 'utf8');
+
+  console.log(`Merged ${inputs.length} files -> ${outputFile}`);
+}
+
+try {
+  run();
+} catch (error) {
+  console.error(error);
+  // eslint-disable-next-line n/no-process-exit
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@alauda-fe/dynamic-plugin-sdk-rspack",
+  "version": "0.0.1-alpha.1",
+  "type": "module",
+  "main": "./index.js",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "css-loader": ">=6.0.0",
+    "monaco-editor-webpack-plugin": "^7.1.1",
+    "style-loader": ">=3.0.0"
+  },
+  "dependencies": {
+    "@rspack/core": "1.6.8",
+    "@rspack/dev-server": "1.2.1"
+  },
+  "packageManager": "yarn@4.16.0",
+  "resolutions": {
+    "bin-wrapper": "npm:bin-wrapper-china@latest"
+  },
+  "module": "./index.js"
+}

package/src/index.d.ts

@@ -0,0 +1,9 @@
+import mfeConfigUtils from './lib/mfe-config-utils';
+import withAlaudaConsole from './lib/with-alauda-console';
+import withBaseConfig from './lib/with-base-config';
+import withHostMfeConfig from './lib/with-host-mfe-config';
+import withMonacoEditor from './lib/with-monaco-editor';
+import withRemoteMfeConfig from './lib/with-remote-mfe-config';
+import withYamlLoader from './lib/with-yaml-loader';
+export { compose, log } from './lib/utils';
+export { mfeConfigUtils, withAlaudaConsole, withBaseConfig, withHostMfeConfig, withMonacoEditor, withRemoteMfeConfig, withYamlLoader, };

package/src/lib/mfe-config-utils.d.ts

@@ -0,0 +1,10 @@
+import type { SharedLibraryConfig } from '@nx/module-federation';
+declare const _default: {
+    shared: (packageName: string, config: SharedLibraryConfig) => false | {
+        singleton: boolean;
+        strictVersion: boolean;
+        requiredVersion?: false | string;
+        eager?: boolean;
+    };
+};
+export default _default;

package/src/lib/utils.d.ts

@@ -0,0 +1,4 @@
+import { type Configuration } from '@rspack/core';
+declare const compose: (...fns: Array<(config: Configuration) => Configuration>) => (v: Configuration) => import("@rspack/core").RspackOptions;
+declare const log: <T>(v: T, ...messages: unknown[]) => T;
+export { compose, log };

package/src/lib/with-alauda-console.d.ts

@@ -0,0 +1,4 @@
+import { type BuildOptions } from '@alauda/custom-webpack';
+import type { Configuration } from '@rspack/core';
+declare const _default: (options?: BuildOptions) => Promise<(config: Configuration) => import("@rspack/core").RspackOptions>;
+export default _default;

package/src/lib/with-base-config.d.ts

@@ -0,0 +1,3 @@
+import type { Configuration } from '@rspack/core';
+declare const _default: () => (config: Configuration) => import("@rspack/core").RspackOptions;
+export default _default;

package/src/lib/with-host-mfe-config.d.ts

@@ -0,0 +1,6 @@
+import type { ModuleFederationConfig, NxModuleFederationConfigOverride } from '@nx/module-federation';
+import type { Configuration } from '@rspack/core';
+declare const _default: (mfeConfig: ModuleFederationConfig, overrideConfig?: NxModuleFederationConfigOverride, options?: {
+    disableDevPluginProxy?: boolean;
+}) => Promise<(config: Configuration) => import("@rspack/core").RspackOptions>;
+export default _default;

package/src/lib/with-monaco-editor.d.ts

@@ -0,0 +1,3 @@
+import type { Configuration } from '@rspack/core';
+declare const _default: () => (config: Configuration) => import("@rspack/core").RspackOptions;
+export default _default;

package/src/lib/with-remote-mfe-config.d.ts

@@ -0,0 +1,4 @@
+import type { ModuleFederationConfig, NxModuleFederationConfigOverride } from '@nx/module-federation';
+import type { Configuration } from '@rspack/core';
+declare const _default: (mfeConfig: ModuleFederationConfig, overrideConfig?: NxModuleFederationConfigOverride) => Promise<(config: Configuration) => import("@rspack/core").RspackOptions>;
+export default _default;

package/src/lib/with-yaml-loader.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => (config: any) => any;
+export default _default;