@teambit/webpack 0.0.737 → 0.0.740

package/transformers/resolve-peer.ts

@@ -0,0 +1,63 @@
+import fs, { realpathSync } from 'fs';
+import { ResolverFactory, CachedInputFileSystem } from 'enhanced-resolve';
+import findRoot from 'find-root';
+import { Logger } from '@teambit/logger';
+
+/**
+ * Get the package folder, and in case it's not found get the resolved file path
+ * @param peerName
+ * @returns
+ */
+export function resolvePeerToDirOrFile(peerName: string, logger: Logger, hostRootDir?: string): string | undefined {
+  let resolved;
+  try {
+    const options = {
+      // resolve the host root dir to its real location, as require.resolve is preserve symlink, so we get wrong result otherwise
+      paths: [process.cwd(), __dirname],
+    };
+    if (hostRootDir) {
+      // resolve the host root dir to its real location, as require.resolve is preserve symlink, so we get wrong result otherwise
+      options.paths.unshift(realpathSync(hostRootDir));
+    }
+
+    resolved = require.resolve(peerName, options);
+    const folder = findRoot(resolved);
+    return folder;
+  } catch (e) {
+    if (resolved) {
+      logger.warn(`Couldn't find root dir for "${peerName}" from path "${resolved}" to add it as webpack alias`);
+    } else {
+      logger.warn(`Couldn't resolve "${peerName}" to add it as webpack alias`);
+    }
+    return resolved;
+  }
+}
+
+/**
+ * Make sure to resolve the peer path correctly
+ * we first resolve it to its dir (to be aligned with the aliases transformer)
+ * Then we resolve it to specific file, using enhanced resolve to make sure we resolve it using the correct main fields order
+ * @param peer
+ */
+export function resolvePeerToFile(peer: string, logger: Logger, hostRootDir?: string): string | undefined {
+  const dirOrFile = resolvePeerToDirOrFile(peer, logger, hostRootDir);
+  if (!dirOrFile) return undefined;
+  const resolver = createResolver();
+  const resolvedFile = resolver.resolveSync({}, '', dirOrFile);
+  return resolvedFile;
+}
+
+/**
+ * Generate a resolver that will read first the module field then the main field
+ * to make it compatible with webpack behavior
+ * @returns
+ */
+function createResolver() {
+  // create a resolver
+  const myResolver = ResolverFactory.createResolver({
+    fileSystem: new CachedInputFileSystem(fs, 4000),
+    useSyncFileSystemCalls: true,
+    mainFields: ['module', 'main'],
+  });
+  return myResolver;
+}

package/transformers/transformers.ts

@@ -0,0 +1,52 @@
+import { WebpackConfigTransformContext } from '@teambit/webpack';
+import { WebpackConfigMutator } from '@teambit/webpack.modules.config-mutator';
+import { Logger } from '@teambit/logger';
+import { getExposedRules } from './get-exposed-rules';
+import { resolvePeerToDirOrFile } from './resolve-peer';
+import { getExternals } from './get-externals';
+
+export function generateAddAliasesFromPeersTransformer(peers: string[], logger: Logger) {
+  return (config: WebpackConfigMutator, context: WebpackConfigTransformContext): WebpackConfigMutator => {
+    const peerAliases = peers.reduce((acc, peerName) => {
+      // gets the correct module folder of the package.
+      // this allows us to resolve internal files, for example:
+      // node_modules/react-dom/test-utils
+      //
+      // we can't use require.resolve() because it resolves to a specific file.
+      // for example, if we used "react-dom": require.resolve("react-dom"),
+      // it would try to resolve "react-dom/test-utils" as:
+      // node_modules/react-dom/index.js/test-utils
+      acc[peerName] = resolvePeerToDirOrFile(peerName, logger, context.target?.hostRootDir);
+      return acc;
+    }, {});
+
+    config.addAliases(peerAliases);
+    return config;
+  };
+}
+
+/**
+ * Generate a transformer that expose all the peers as global via the expose loader
+ * @param peers
+ * @returns
+ */
+export function generateExposePeersTransformer(peers: string[], logger: Logger) {
+  return (config: WebpackConfigMutator, context: WebpackConfigTransformContext): WebpackConfigMutator => {
+    const exposedRules = getExposedRules(peers, logger, context.target?.hostRootDir);
+    config.addModuleRules(exposedRules);
+    return config;
+  };
+}
+
+/**
+ * Generate a transformer that expose all the peers as global via the expose loader
+ * @param peers
+ * @returns
+ */
+export function generateExternalsTransformer(depes: string[]) {
+  return (config: WebpackConfigMutator): WebpackConfigMutator => {
+    const externals = getExternals(depes);
+    config.addExternals(externals);
+    return config;
+  };
+}