@touk/federated-types 1.3.0-beta.5 → 1.3.0-beta.7

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

@@ -68,6 +68,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 +156,73 @@ function getModuleDeclareName(exposeName) {
     return path.join(federationConfig.name, exposeName).replace(/[\\/]/g, '/');
 }
 
+// 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`);
@@ -162,9 +230,6 @@ try {
         fs.unlinkSync(outFile);
     }
 
-    const tsBuildInfoFile = path.resolve(process.cwd(), 'node_modules', '.cache', 'federated-types', `${federationConfig.name}.tsbuildinfo`);
-    fs.mkdirSync(path.dirname(tsBuildInfoFile), { recursive: true });
-
     // write the typings file
     const program = ts.createProgram(compileFiles, {
         outFile,
@@ -172,8 +237,6 @@ try {
         emitDeclarationOnly: true,
         skipLibCheck: true,
         noCheck: true,
-        incremental: true,
-        tsBuildInfoFile,
         jsx: ts.JsxEmit.React,
         esModuleInterop: true,
     });
@@ -189,35 +252,54 @@ try {
     let typing = fs.readFileSync(outFile, { encoding: 'utf8', flag: 'r' });
 
     const moduleRegex = RegExp(/declare module "(.*)"/, 'g');
-    const moduleNames = [];
+    const exposedPaths = compileKeys.map((key) => [
+        key,
+        federationConfig.exposes[key].replace(/\.(tsx?|jsx?)$/, ''),
+    ]);
+    const findExposeKeys = (name) =>
+        exposedPaths
+            .filter(([, normalizedPath]) => normalizedPath.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();
+    const aliasModules = [];
 
     let execResults;
     while ((execResults = moduleRegex.exec(typing)) !== null) {
-        moduleNames.push(execResults[1]);
-    }
+        const name = execResults[1];
+        if (renames.has(name)) {
+            continue;
+        }
 
-    moduleNames.forEach((name) => {
         // exposeName - relative name of exposed component (if not found - just take moduleName)
-        const [exposeName = name, ...aliases] = compileKeys.filter((key) => {
-            const normalizedPath = federationConfig.exposes[key].replace(/\.(tsx?|jsx?)$/, '');
-            return normalizedPath.endsWith(name);
-        });
-        const regex = RegExp(`"${name}"`, 'g');
+        const [exposeName = name, ...aliases] = findExposeKeys(name);
 
         const moduleDeclareName = getModuleDeclareName(exposeName);
+        renames.set(name, moduleDeclareName);
 
         // language=TypeScript
-        const createAliasModule = (name) => `
-            declare module "${getModuleDeclareName(name)}" {
+        aliases.forEach((alias) =>
+            aliasModules.push(`
+            declare module "${getModuleDeclareName(alias)}" {
                 export * from "${moduleDeclareName}"
             }
-        `;
+        `)
+        );
+    }
 
-        typing = [
-            typing.replace(regex, `"${moduleDeclareName}"`),
-            ...aliases.map(createAliasModule),
-        ].join('\n');
-    });
+    if (renames.size > 0) {
+        // Rename every exact quoted occurrence of a module name in a single pass.
+        const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const namesRegex = RegExp(`"(${Array.from(renames.keys(), escapeRegExp).join('|')})"`, 'g');
+        typing = typing.replace(namesRegex, (match, name) => `"${renames.get(name)}"`);
+    }
+
+    typing = [typing, ...aliasModules].join('\n');
 
     outputDirs.forEach((_outputDir) => {
         const _outFile = path.resolve(_outputDir, `${federationConfig.name}.d.ts`);

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.5",
+    "version": "1.3.0-beta.7",
     "author": "Julian Wielga <j@touk.pl>",
     "bin": {
         "make-federated-types": "./cli.js"