@touk/federated-types 1.3.0-beta.6 → 1.3.0-beta.8

package/README.md

@@ -82,6 +82,20 @@ scripts: {
 }
 ```
 
+## Pruning unreachable modules
+
+By default the generated typings contain every module of the TypeScript program built from your exposes, including modules that are only used by their implementation. Pass `--prune` to keep only the modules reachable from the exposed modules through their types (`import`/`export ... from`, `import("...")`, `import "..."`, `require("...")`):
+
+```javascript
+//package.json
+
+scripts: {
+    "make-types": "make-federated-types --prune"
+}
+```
+
+Modules that augment the global scope (`declare global`) or other modules are always kept. With `--prune`, non-exposed modules can no longer be imported by their deep name (e.g. `myApp/utils/internal`) unless they are reachable from an exposed module.
+
 ## Inline configuration (without config file)
 
 If you prefer not to maintain a separate `federation.config.json` file, you can provide the configuration directly via CLI arguments using `--name` and `--exposes`:

package/cli.js

@@ -2,7 +2,6 @@
 
 const path = require('path');
 const fs = require('fs');
-const findNodeModules = require('find-node-modules');
 const ts = require('typescript');
 const chalk = require('chalk');
 
@@ -20,7 +19,20 @@ function reportDiagnostic(diagnostic) {
     );
 }
 
-const [nodeModules] = findNodeModules({ cwd: process.argv[1], relative: false });
+// nearest node_modules directory up from the CLI script
+const findNodeModules = (start) => {
+    let dir = path.resolve(start);
+    while (!fs.existsSync(path.join(dir, 'node_modules'))) {
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            return path.resolve('node_modules');
+        }
+        dir = parent;
+    }
+    return path.join(dir, 'node_modules');
+};
+
+const nodeModules = findNodeModules(process.argv[1]);
 
 const hasArg = (argName) => {
     const argIndex = process.argv.indexOf(argName);
@@ -68,6 +80,7 @@ const configPath = configPathArg ? path.resolve(configPathArg) : null;
 const nameArg = getArg('--name');
 const exposesArgs = getAllArgs('--exposes');
 const verboseArg = hasArg('--verbose') || process.env.npm_config_loglevel === 'verbose';
+const pruneArg = hasArg('--prune');
 
 const log = (...args) => console.log(...args);
 const logDebug = (...args) => verboseArg && console.debug(chalk.gray.dim(...args));
@@ -155,6 +168,102 @@ function getModuleDeclareName(exposeName) {
     return path.join(federationConfig.name, exposeName).replace(/[\\/]/g, '/');
 }
 
+const toPosixPath = (value) => value.replace(/[\\/]/g, '/');
+const stripSourceExtension = (file) => file.replace(/\.(d\.ts|[cm]?tsx?|[cm]?jsx?)$/, '');
+
+/**
+ * Maps the absolute path (without extension) of every source file in the program to the module
+ * name tsc gives it in an outFile bundle: its path relative to the common source directory.
+ * Exposes outside of the exposing package (e.g. a package importing a sibling's sources) move
+ * that directory up, so the module name cannot be derived from the configured path alone.
+ */
+function getEmittedModuleNames(program) {
+    // internal, but stable TypeScript API; fall back to suffix matching without it
+    if (typeof program.getCommonSourceDirectory !== 'function') {
+        return new Map();
+    }
+    const commonSourceDirectory = program.getCommonSourceDirectory();
+    return new Map(
+        program
+            .getSourceFiles()
+            .filter((sourceFile) => !sourceFile.isDeclarationFile)
+            .map((sourceFile) => {
+                const absolutePath = stripSourceExtension(path.resolve(sourceFile.fileName));
+                return [
+                    toPosixPath(absolutePath),
+                    toPosixPath(path.relative(commonSourceDirectory, absolutePath)),
+                ];
+            })
+    );
+}
+
+// Matches the module specifier of `from "x"`, `import("x")`, `import "x"` and `require("x")`.
+const moduleReferenceRegex = /\b(?:from|import|require)\s*\(?\s*(["'])([^"'\n]+)\1/g;
+// Global or module augmentations take effect without being imported, so such modules are always kept.
+// Inside a `declare module` block tsc emits them without the `declare` keyword.
+const augmentationRegex = /^\s+(?:declare\s+)?(?:global\s*\{|module\s+["'])/m;
+
+/**
+ * Drops the top-level `declare module` blocks that cannot be reached from the exposed modules
+ * through module references. Text outside the blocks is kept as is.
+ */
+function pruneUnreachableModules(typing, isExposedModule) {
+    const blockRegex = /^declare module "([^"]+)" \{\n[\s\S]*?^\}\n?/gm;
+    const segments = [];
+    const modules = new Map();
+    let lastIndex = 0;
+    let match;
+
+    while ((match = blockRegex.exec(typing)) !== null) {
+        segments.push(typing.slice(lastIndex, match.index));
+        const block = { name: match[1], text: match[0] };
+        segments.push(block);
+        modules.set(block.name, block);
+        lastIndex = blockRegex.lastIndex;
+    }
+    segments.push(typing.slice(lastIndex));
+
+    const roots = Array.from(modules.values()).filter(
+        (block) => isExposedModule(block.name) || augmentationRegex.test(block.text)
+    );
+
+    if (!roots.some((block) => isExposedModule(block.name))) {
+        console.warn(
+            chalk.yellow('WARNING:'),
+            'No exposed module found in the emitted typings, skipping --prune'
+        );
+        return typing;
+    }
+
+    const reachable = new Set();
+    const queue = [];
+    const visit = (text) => {
+        for (const [, , name] of text.matchAll(moduleReferenceRegex)) {
+            const block = modules.get(name);
+            if (block && !reachable.has(block)) {
+                reachable.add(block);
+                queue.push(block);
+            }
+        }
+    };
+
+    segments.filter((segment) => typeof segment === 'string').forEach(visit);
+    roots.forEach((block) => {
+        reachable.add(block);
+        queue.push(block);
+    });
+    while (queue.length > 0) {
+        visit(queue.pop().text);
+    }
+
+    logDebug(`--prune: kept ${reachable.size} of ${modules.size} modules`);
+
+    return segments
+        .filter((segment) => typeof segment === 'string' || reachable.has(segment))
+        .map((segment) => (typeof segment === 'string' ? segment : segment.text))
+        .join('');
+}
+
 try {
     fs.mkdirSync(outputDir, { recursive: true });
     const outFile = path.resolve(outputDir, `${federationConfig.name}.d.ts`);
@@ -184,10 +293,30 @@ try {
     let typing = fs.readFileSync(outFile, { encoding: 'utf8', flag: 'r' });
 
     const moduleRegex = RegExp(/declare module "(.*)"/, 'g');
-    const exposedPaths = compileKeys.map((key) => [
-        key,
-        federationConfig.exposes[key].replace(/\.(tsx?|jsx?)$/, ''),
-    ]);
+    const emittedModuleNames = getEmittedModuleNames(program);
+    const exposedModules = compileKeys.map((key) => {
+        const exposePath = federationConfig.exposes[key];
+        const absolutePath = toPosixPath(stripSourceExtension(path.resolve(exposePath)));
+        return {
+            key,
+            relativePath: exposePath.replace(/\.(tsx?|jsx?)$/, ''),
+            moduleName:
+                emittedModuleNames.get(absolutePath) ??
+                emittedModuleNames.get(`${absolutePath}/index`),
+        };
+    });
+    // Falls back to suffix matching of the configured path when the source file could not be
+    // resolved in the program.
+    const findExposeKeys = (name) =>
+        exposedModules
+            .filter(({ relativePath, moduleName }) =>
+                moduleName !== undefined ? moduleName === name : relativePath.endsWith(name)
+            )
+            .map(({ key }) => key);
+
+    if (pruneArg) {
+        typing = pruneUnreachableModules(typing, (name) => findExposeKeys(name).length > 0);
+    }
 
     // module name emitted by tsc -> name it is declared under in the federated typings
     const renames = new Map();
@@ -201,9 +330,7 @@ try {
         }
 
         // exposeName - relative name of exposed component (if not found - just take moduleName)
-        const [exposeName = name, ...aliases] = exposedPaths
-            .filter(([, normalizedPath]) => normalizedPath.endsWith(name))
-            .map(([key]) => key);
+        const [exposeName = name, ...aliases] = findExposeKeys(name);
 
         const moduleDeclareName = getModuleDeclareName(exposeName);
         renames.set(name, moduleDeclareName);

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@touk/federated-types",
     "description": "share typings for your federated typescript packages around your mono-repo",
-    "version": "1.3.0-beta.6",
+    "version": "1.3.0-beta.8",
     "author": "Julian Wielga <j@touk.pl>",
     "bin": {
         "make-federated-types": "./cli.js"
@@ -10,8 +10,7 @@
         "Jonathan Greene <jgreene@pixability.com>"
     ],
     "dependencies": {
-        "chalk": "^4.1.2",
-        "find-node-modules": "2.1.3"
+        "chalk": "^4.1.2"
     },
     "devDependencies": {
         "@commitlint/cli": "^20.4.2",