@module-federation/native-federation-typescript 0.1.0 → 0.1.2

package/dist/chunk-JLWFNRJL.js

@@ -0,0 +1,179 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+
+var _chunkVHQW5BQSjs = require('./chunk-VHQW5BQS.js');
+
+
+
+
+var _chunk2NC7LVYZjs = require('./chunk-2NC7LVYZ.js');
+
+// packages/native-federation-typescript/src/index.ts
+var _unplugin = require('unplugin');
+var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
+var NativeFederationTypeScriptRemote = _unplugin.createUnplugin.call(void 0, 
+  (enhancedOptions) => {
+    const options = "extraOptions" in enhancedOptions ? enhancedOptions.remote : enhancedOptions;
+    const extraOptions = "extraOptions" in enhancedOptions ? enhancedOptions.extraOptions : void 0;
+    _chunk2NC7LVYZjs.validateOptions.call(void 0, options);
+    const isProd = process.env.NODE_ENV === "production";
+    const generateTypesOptions = {
+      remote: options,
+      extraOptions
+    };
+    const getGenerateTypesFn = () => {
+      let fn = _chunk2NC7LVYZjs.generateTypes;
+      let res;
+      if (options.compileInChildProcess) {
+        fn = _chunkVHQW5BQSjs.generateTypesInChildProcess;
+      }
+      if (isProd) {
+        res = fn(generateTypesOptions);
+        return () => res;
+      }
+      return fn;
+    };
+    const generateTypesFn = getGenerateTypesFn();
+    return {
+      name: "native-federation-typescript/remote",
+      rollup: {
+        writeBundle: async () => {
+          await generateTypesFn(generateTypesOptions);
+        }
+      },
+      vite: {
+        buildStart: async () => {
+          if (isProd) {
+            return;
+          }
+          await generateTypesFn(generateTypesOptions);
+        },
+        watchChange: async () => {
+          if (isProd) {
+            return;
+          }
+          await generateTypesFn(generateTypesOptions);
+        },
+        writeBundle: async () => {
+          await generateTypesFn(generateTypesOptions);
+        }
+      },
+      webpack: (compiler) => {
+        compiler.hooks.thisCompilation.tap("generateTypes", (compilation) => {
+          const hookName = "mf:generateTypes";
+          compilation.hooks.processAssets.tapPromise(
+            {
+              name: hookName,
+              stage: (
+                // @ts-expect-error use runtime variable in case peer dep not installed
+                compilation.constructor.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER
+              )
+            },
+            async () => {
+              try {
+                const { zipTypesPath, apiTypesPath, zipName, apiFileName } = _chunk2NC7LVYZjs.retrieveTypesAssetsInfo.call(void 0, options);
+                if (zipName && compilation.getAsset(zipName)) {
+                  return;
+                }
+                await generateTypesFn(generateTypesOptions);
+                if (zipTypesPath) {
+                  compilation.emitAsset(
+                    zipName,
+                    new compiler.webpack.sources.RawSource(
+                      _fs2.default.readFileSync(zipTypesPath),
+                      false
+                    )
+                  );
+                }
+                if (apiTypesPath) {
+                  compilation.emitAsset(
+                    apiFileName,
+                    new compiler.webpack.sources.RawSource(
+                      _fs2.default.readFileSync(apiTypesPath),
+                      false
+                    )
+                  );
+                }
+              } catch (err) {
+                console.error(err);
+              }
+            }
+          );
+        });
+      },
+      rspack: (compiler) => {
+        compiler.hooks.thisCompilation.tap("generateTypes", (compilation) => {
+          const hookName = "mf:generateTypes";
+          compilation.hooks.processAssets.tapPromise(
+            {
+              name: hookName,
+              stage: (
+                // @ts-expect-error use runtime variable in case peer dep not installed
+                compilation.constructor.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER
+              )
+            },
+            async () => {
+              try {
+                const { zipTypesPath, apiTypesPath, zipName, apiFileName } = _chunk2NC7LVYZjs.retrieveTypesAssetsInfo.call(void 0, options);
+                if (zipName && compilation.getAsset(zipName)) {
+                  return;
+                }
+                await generateTypesFn(generateTypesOptions);
+                if (zipTypesPath) {
+                  compilation.emitAsset(
+                    zipName,
+                    new compiler.webpack.sources.RawSource(
+                      _fs2.default.readFileSync(zipTypesPath),
+                      false
+                    )
+                  );
+                }
+                if (apiTypesPath) {
+                  compilation.emitAsset(
+                    apiFileName,
+                    new compiler.webpack.sources.RawSource(
+                      _fs2.default.readFileSync(apiTypesPath),
+                      false
+                    )
+                  );
+                }
+              } catch (err) {
+                console.error(err);
+              }
+            }
+          );
+        });
+      }
+    };
+  }
+);
+var NativeFederationTypeScriptHost = _unplugin.createUnplugin.call(void 0, 
+  (enhancedOptions) => {
+    const options = "extraOptions" in enhancedOptions ? enhancedOptions.host : enhancedOptions;
+    const extraOptions = "extraOptions" in enhancedOptions ? enhancedOptions.extraOptions : void 0;
+    _chunk2NC7LVYZjs.validateOptions.call(void 0, options);
+    const consumeTypesOptions = {
+      host: options,
+      extraOptions
+    };
+    const consumeTypesPromise = _chunkVHQW5BQSjs.consumeTypes.call(void 0, consumeTypesOptions);
+    return {
+      name: "native-federation-typescript/host",
+      async writeBundle() {
+        await consumeTypesPromise;
+      },
+      get vite() {
+        return process.env.NODE_ENV === "production" ? void 0 : {
+          buildStart: async () => {
+            await consumeTypesPromise;
+          }
+        };
+      }
+    };
+  }
+);
+
+
+
+
+exports.NativeFederationTypeScriptRemote = NativeFederationTypeScriptRemote; exports.NativeFederationTypeScriptHost = NativeFederationTypeScriptHost;

package/dist/chunk-QYHGZU7D.mjs

@@ -0,0 +1,244 @@
+import {
+  RpcGMCallTypes,
+  __export,
+  exposeRpc,
+  getDTSManagerConstructor
+} from "./chunk-CF5CH54A.mjs";
+
+// packages/native-federation-typescript/src/lib/DtsWorker.ts
+import path from "path";
+import cloneDeepWith from "lodash.clonedeepwith";
+
+// packages/native-federation-typescript/src/rpc/index.ts
+var rpc_exports = {};
+__export(rpc_exports, {
+  RpcExitError: () => RpcExitError,
+  RpcGMCallTypes: () => RpcGMCallTypes,
+  createRpcWorker: () => createRpcWorker,
+  exposeRpc: () => exposeRpc,
+  getRpcWorkerData: () => getRpcWorkerData,
+  wrapRpc: () => wrapRpc
+});
+
+// packages/native-federation-typescript/src/rpc/rpc-error.ts
+var RpcExitError = class extends Error {
+  constructor(message, code, signal) {
+    super(message);
+    this.code = code;
+    this.signal = signal;
+    this.name = "RpcExitError";
+  }
+};
+
+// packages/native-federation-typescript/src/rpc/wrap-rpc.ts
+function createControlledPromise() {
+  let resolve = () => void 0;
+  let reject = () => void 0;
+  const promise = new Promise((aResolve, aReject) => {
+    resolve = aResolve;
+    reject = aReject;
+  });
+  return {
+    promise,
+    resolve,
+    reject
+  };
+}
+function wrapRpc(childProcess, options) {
+  return async (...args) => {
+    if (!childProcess.send) {
+      throw new Error(`Process ${childProcess.pid} doesn't have IPC channels`);
+    } else if (!childProcess.connected) {
+      throw new Error(
+        `Process ${childProcess.pid} doesn't have open IPC channels`
+      );
+    }
+    const { id, once } = options;
+    const {
+      promise: resultPromise,
+      resolve: resolveResult,
+      reject: rejectResult
+    } = createControlledPromise();
+    const {
+      promise: sendPromise,
+      resolve: resolveSend,
+      reject: rejectSend
+    } = createControlledPromise();
+    const handleMessage = (message) => {
+      if ((message == null ? void 0 : message.id) === id) {
+        if (message.type === "mf_resolve" /* RESOLVE */) {
+          resolveResult(message.value);
+          if (once) {
+            removeHandlers();
+          }
+        } else if (message.type === "mf_reject" /* REJECT */) {
+          rejectResult(message.error);
+          if (once) {
+            removeHandlers();
+          }
+        }
+      }
+    };
+    const handleClose = (code, signal) => {
+      rejectResult(
+        new RpcExitError(
+          code ? `Process ${childProcess.pid} exited with code ${code}${signal ? ` [${signal}]` : ""}` : `Process ${childProcess.pid} exited${signal ? ` [${signal}]` : ""}`,
+          code,
+          signal
+        )
+      );
+      removeHandlers();
+    };
+    const removeHandlers = () => {
+      childProcess.off("message", handleMessage);
+      childProcess.off("close", handleClose);
+    };
+    childProcess.on("message", handleMessage);
+    childProcess.on("close", handleClose);
+    childProcess.on("error", (err) => {
+      console.error(err);
+    });
+    childProcess.send(
+      {
+        type: "mf_call" /* CALL */,
+        id,
+        args
+      },
+      (error) => {
+        if (error) {
+          rejectSend(error);
+          removeHandlers();
+        } else {
+          resolveSend(void 0);
+        }
+      }
+    );
+    return sendPromise.then(() => resultPromise);
+  };
+}
+
+// packages/native-federation-typescript/src/rpc/rpc-worker.ts
+import * as child_process from "child_process";
+import * as process from "process";
+var FEDERATION_WORKER_DATA_ENV_KEY = "VMOK_WORKER_DATA_ENV";
+function uuid() {
+  return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+}
+function createRpcWorker(modulePath, data, memoryLimit, once) {
+  const options = {
+    env: {
+      ...process.env,
+      [FEDERATION_WORKER_DATA_ENV_KEY]: JSON.stringify(data || {})
+    },
+    stdio: ["inherit", "inherit", "inherit", "ipc"],
+    serialization: "advanced"
+  };
+  if (memoryLimit) {
+    options.execArgv = [`--max-old-space-size=${memoryLimit}`];
+  }
+  let childProcess, remoteMethod;
+  const id = uuid();
+  const worker = {
+    connect(...args) {
+      if (childProcess && !childProcess.connected) {
+        childProcess.send({
+          type: "mf_exit" /* EXIT */,
+          id
+        });
+        childProcess = void 0;
+        remoteMethod = void 0;
+      }
+      if (!(childProcess == null ? void 0 : childProcess.connected)) {
+        childProcess = child_process.fork(modulePath, options);
+        remoteMethod = wrapRpc(childProcess, { id, once });
+      }
+      if (!remoteMethod) {
+        return Promise.reject("Worker is not connected - cannot perform RPC.");
+      }
+      return remoteMethod(...args);
+    },
+    terminate() {
+      if (childProcess) {
+        childProcess.send({
+          type: "mf_exit" /* EXIT */,
+          id
+        });
+        childProcess = void 0;
+        remoteMethod = void 0;
+      }
+    },
+    get connected() {
+      return Boolean(childProcess == null ? void 0 : childProcess.connected);
+    },
+    get process() {
+      return childProcess;
+    },
+    get id() {
+      return id;
+    }
+  };
+  return worker;
+}
+function getRpcWorkerData() {
+  return JSON.parse(process.env[FEDERATION_WORKER_DATA_ENV_KEY] || "{}");
+}
+
+// packages/native-federation-typescript/src/lib/DtsWorker.ts
+var DtsWorker = class {
+  constructor(options) {
+    this._options = cloneDeepWith(options, (_value, key) => {
+      if (key === "manifest") {
+        return false;
+      }
+    });
+    this.removeUnSerializationOptions();
+    this._rpcWorker = createRpcWorker(
+      path.resolve(__dirname, "./lib/forkGenerateDts.js"),
+      {},
+      void 0,
+      true
+    );
+    this._res = this._rpcWorker.connect(this._options);
+    Promise.resolve(this._res).then(() => {
+      this.exit();
+    });
+  }
+  removeUnSerializationOptions() {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if ((_b = (_a = this._options.remote) == null ? void 0 : _a.moduleFederationConfig) == null ? void 0 : _b.manifest) {
+      (_d = (_c = this._options.remote) == null ? void 0 : _c.moduleFederationConfig) == null ? true : delete _d.manifest;
+    }
+    if ((_f = (_e = this._options.host) == null ? void 0 : _e.moduleFederationConfig) == null ? void 0 : _f.manifest) {
+      (_h = (_g = this._options.host) == null ? void 0 : _g.moduleFederationConfig) == null ? true : delete _h.manifest;
+    }
+  }
+  get controlledPromise() {
+    return this._res;
+  }
+  exit() {
+    var _a;
+    (_a = this._rpcWorker) == null ? void 0 : _a.terminate();
+  }
+};
+
+// packages/native-federation-typescript/src/lib/generateTypesInChildProcess.ts
+async function generateTypesInChildProcess(options) {
+  const dtsWorker = new DtsWorker(options);
+  return dtsWorker.controlledPromise;
+}
+
+// packages/native-federation-typescript/src/lib/consumeTypes.ts
+async function consumeTypes(options) {
+  var _a;
+  const DTSManagerConstructor = getDTSManagerConstructor(
+    (_a = options.host) == null ? void 0 : _a.implementation
+  );
+  const dtsManager = new DTSManagerConstructor(options);
+  await dtsManager.consumeTypes();
+}
+
+export {
+  rpc_exports,
+  generateTypesInChildProcess,
+  consumeTypes
+};

package/dist/chunk-VHQW5BQS.js

@@ -0,0 +1,244 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+
+
+
+var _chunk2NC7LVYZjs = require('./chunk-2NC7LVYZ.js');
+
+// packages/native-federation-typescript/src/lib/DtsWorker.ts
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _lodashclonedeepwith = require('lodash.clonedeepwith'); var _lodashclonedeepwith2 = _interopRequireDefault(_lodashclonedeepwith);
+
+// packages/native-federation-typescript/src/rpc/index.ts
+var rpc_exports = {};
+_chunk2NC7LVYZjs.__export.call(void 0, rpc_exports, {
+  RpcExitError: () => RpcExitError,
+  RpcGMCallTypes: () => _chunk2NC7LVYZjs.RpcGMCallTypes,
+  createRpcWorker: () => createRpcWorker,
+  exposeRpc: () => _chunk2NC7LVYZjs.exposeRpc,
+  getRpcWorkerData: () => getRpcWorkerData,
+  wrapRpc: () => wrapRpc
+});
+
+// packages/native-federation-typescript/src/rpc/rpc-error.ts
+var RpcExitError = class extends Error {
+  constructor(message, code, signal) {
+    super(message);
+    this.code = code;
+    this.signal = signal;
+    this.name = "RpcExitError";
+  }
+};
+
+// packages/native-federation-typescript/src/rpc/wrap-rpc.ts
+function createControlledPromise() {
+  let resolve = () => void 0;
+  let reject = () => void 0;
+  const promise = new Promise((aResolve, aReject) => {
+    resolve = aResolve;
+    reject = aReject;
+  });
+  return {
+    promise,
+    resolve,
+    reject
+  };
+}
+function wrapRpc(childProcess, options) {
+  return async (...args) => {
+    if (!childProcess.send) {
+      throw new Error(`Process ${childProcess.pid} doesn't have IPC channels`);
+    } else if (!childProcess.connected) {
+      throw new Error(
+        `Process ${childProcess.pid} doesn't have open IPC channels`
+      );
+    }
+    const { id, once } = options;
+    const {
+      promise: resultPromise,
+      resolve: resolveResult,
+      reject: rejectResult
+    } = createControlledPromise();
+    const {
+      promise: sendPromise,
+      resolve: resolveSend,
+      reject: rejectSend
+    } = createControlledPromise();
+    const handleMessage = (message) => {
+      if ((message == null ? void 0 : message.id) === id) {
+        if (message.type === "mf_resolve" /* RESOLVE */) {
+          resolveResult(message.value);
+          if (once) {
+            removeHandlers();
+          }
+        } else if (message.type === "mf_reject" /* REJECT */) {
+          rejectResult(message.error);
+          if (once) {
+            removeHandlers();
+          }
+        }
+      }
+    };
+    const handleClose = (code, signal) => {
+      rejectResult(
+        new RpcExitError(
+          code ? `Process ${childProcess.pid} exited with code ${code}${signal ? ` [${signal}]` : ""}` : `Process ${childProcess.pid} exited${signal ? ` [${signal}]` : ""}`,
+          code,
+          signal
+        )
+      );
+      removeHandlers();
+    };
+    const removeHandlers = () => {
+      childProcess.off("message", handleMessage);
+      childProcess.off("close", handleClose);
+    };
+    childProcess.on("message", handleMessage);
+    childProcess.on("close", handleClose);
+    childProcess.on("error", (err) => {
+      console.error(err);
+    });
+    childProcess.send(
+      {
+        type: "mf_call" /* CALL */,
+        id,
+        args
+      },
+      (error) => {
+        if (error) {
+          rejectSend(error);
+          removeHandlers();
+        } else {
+          resolveSend(void 0);
+        }
+      }
+    );
+    return sendPromise.then(() => resultPromise);
+  };
+}
+
+// packages/native-federation-typescript/src/rpc/rpc-worker.ts
+var _child_process = require('child_process'); var child_process = _interopRequireWildcard(_child_process);
+var _process = require('process'); var process = _interopRequireWildcard(_process);
+var FEDERATION_WORKER_DATA_ENV_KEY = "VMOK_WORKER_DATA_ENV";
+function uuid() {
+  return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+}
+function createRpcWorker(modulePath, data, memoryLimit, once) {
+  const options = {
+    env: {
+      ...process.env,
+      [FEDERATION_WORKER_DATA_ENV_KEY]: JSON.stringify(data || {})
+    },
+    stdio: ["inherit", "inherit", "inherit", "ipc"],
+    serialization: "advanced"
+  };
+  if (memoryLimit) {
+    options.execArgv = [`--max-old-space-size=${memoryLimit}`];
+  }
+  let childProcess, remoteMethod;
+  const id = uuid();
+  const worker = {
+    connect(...args) {
+      if (childProcess && !childProcess.connected) {
+        childProcess.send({
+          type: "mf_exit" /* EXIT */,
+          id
+        });
+        childProcess = void 0;
+        remoteMethod = void 0;
+      }
+      if (!(childProcess == null ? void 0 : childProcess.connected)) {
+        childProcess = child_process.fork(modulePath, options);
+        remoteMethod = wrapRpc(childProcess, { id, once });
+      }
+      if (!remoteMethod) {
+        return Promise.reject("Worker is not connected - cannot perform RPC.");
+      }
+      return remoteMethod(...args);
+    },
+    terminate() {
+      if (childProcess) {
+        childProcess.send({
+          type: "mf_exit" /* EXIT */,
+          id
+        });
+        childProcess = void 0;
+        remoteMethod = void 0;
+      }
+    },
+    get connected() {
+      return Boolean(childProcess == null ? void 0 : childProcess.connected);
+    },
+    get process() {
+      return childProcess;
+    },
+    get id() {
+      return id;
+    }
+  };
+  return worker;
+}
+function getRpcWorkerData() {
+  return JSON.parse(process.env[FEDERATION_WORKER_DATA_ENV_KEY] || "{}");
+}
+
+// packages/native-federation-typescript/src/lib/DtsWorker.ts
+var DtsWorker = class {
+  constructor(options) {
+    this._options = _lodashclonedeepwith2.default.call(void 0, options, (_value, key) => {
+      if (key === "manifest") {
+        return false;
+      }
+    });
+    this.removeUnSerializationOptions();
+    this._rpcWorker = createRpcWorker(
+      _path2.default.resolve(__dirname, "./lib/forkGenerateDts.js"),
+      {},
+      void 0,
+      true
+    );
+    this._res = this._rpcWorker.connect(this._options);
+    Promise.resolve(this._res).then(() => {
+      this.exit();
+    });
+  }
+  removeUnSerializationOptions() {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if ((_b = (_a = this._options.remote) == null ? void 0 : _a.moduleFederationConfig) == null ? void 0 : _b.manifest) {
+      (_d = (_c = this._options.remote) == null ? void 0 : _c.moduleFederationConfig) == null ? true : delete _d.manifest;
+    }
+    if ((_f = (_e = this._options.host) == null ? void 0 : _e.moduleFederationConfig) == null ? void 0 : _f.manifest) {
+      (_h = (_g = this._options.host) == null ? void 0 : _g.moduleFederationConfig) == null ? true : delete _h.manifest;
+    }
+  }
+  get controlledPromise() {
+    return this._res;
+  }
+  exit() {
+    var _a;
+    (_a = this._rpcWorker) == null ? void 0 : _a.terminate();
+  }
+};
+
+// packages/native-federation-typescript/src/lib/generateTypesInChildProcess.ts
+async function generateTypesInChildProcess(options) {
+  const dtsWorker = new DtsWorker(options);
+  return dtsWorker.controlledPromise;
+}
+
+// packages/native-federation-typescript/src/lib/consumeTypes.ts
+async function consumeTypes(options) {
+  var _a;
+  const DTSManagerConstructor = _chunk2NC7LVYZjs.getDTSManagerConstructor.call(void 0, 
+    (_a = options.host) == null ? void 0 : _a.implementation
+  );
+  const dtsManager = new DTSManagerConstructor(options);
+  await dtsManager.consumeTypes();
+}
+
+
+
+
+
+exports.rpc_exports = rpc_exports; exports.generateTypesInChildProcess = generateTypesInChildProcess; exports.consumeTypes = consumeTypes;