@touk/federated-types 1.2.2-beta.1 → 1.3.0-beta.2

package/README.md

@@ -30,7 +30,6 @@ It's recommended that you spread these properties into your ModuleFederationPlug
 ```javascript
 //webpack.config.js
 
-const deps = require('../package.json').dependencies;
 const federationConfig = require('./federation.config.json');
 
 module.exports = {
@@ -40,9 +39,7 @@ module.exports = {
         new ModuleFederationPlugin({
             ...federationConfig,
             filename: "remoteEntry.js",
-            shared: {
-                ...deps,
-            },
+            shared: { ... },
         }),
     ],
 
@@ -84,3 +81,43 @@ scripts: {
     "make-types": "make-federated-types --config ./path/to/my/config.json --outputDir ../../my_types/"
 }
 ```
+
+## 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`:
+
+```bash
+make-federated-types \
+  --name myApp \
+  --exposes App ./src/App.tsx \
+  --exposes Button ./src/components/Button.tsx \
+  --outputDir ./types
+```
+
+### Inline config features:
+
+- **Multiple exposures**: Use `--exposes` multiple times, each followed by a key and file path
+- **Auto-prefix**: Keys without `./` prefix are automatically normalized (e.g., `App` becomes `./App`)
+- **Shell-friendly**: Works with tab completion for file paths
+- **Priority**: Inline config takes precedence over `--config` and auto-discovery
+
+### Examples:
+
+```bash
+# Simple inline config
+make-federated-types --name app2 --exposes Button ./src/Button.tsx
+
+# Multiple exposures
+make-federated-types \
+  --name app2 \
+  --exposes ./Button ./src/Button.tsx \
+  --exposes ./Header ./src/Header.tsx
+
+# Nested keys (auto-prefixed with ./)
+make-federated-types \
+  --name app2 \
+  --exposes components/Button ./src/components/Button.tsx \
+  --exposes utils/helpers ./src/utils/helpers.ts
+```
+
+**Note**: When using inline config, both `--name` and at least one `--exposes` are required.

package/cli.js

@@ -4,6 +4,7 @@ const path = require('path');
 const fs = require('fs');
 const findNodeModules = require('find-node-modules');
 const ts = require('typescript');
+const chalk = require('chalk');
 
 const formatHost = {
     getCurrentDirectory: ts.sys.getCurrentDirectory,
@@ -12,8 +13,8 @@ const formatHost = {
 
 function reportDiagnostic(diagnostic) {
     console.log(
-        'TS Error',
-        diagnostic.code,
+        chalk.red('TS Error'),
+        chalk.yellow(diagnostic.code),
         ':',
         ts.flattenDiagnosticMessageText(diagnostic.messageText, formatHost.getNewLine())
     );
@@ -29,6 +30,26 @@ const getArg = (argName) => {
     const argIndex = process.argv.indexOf(argName);
     return argIndex !== -1 ? process.argv[argIndex + 1] : null;
 };
+const getAllArgs = (argName) => {
+    const results = [];
+    let i = 2; // process.argv starts with node and script path
+
+    while (i < process.argv.length) {
+        if (process.argv[i] === argName) {
+            // Next two arguments are key and value
+            if (i + 2 < process.argv.length) {
+                results.push([process.argv[i + 1], process.argv[i + 2]]);
+                i += 3; // skip argName, key, value
+            } else {
+                console.error(chalk.red('ERROR:'), '--exposes requires two arguments (key path)');
+                process.exit(1);
+            }
+        } else {
+            i++;
+        }
+    }
+    return results;
+};
 
 const nodeModulesOutputDir = path.resolve(nodeModules, '@types/__federated_types/');
 const saveToNodeMoulesArg = hasArg('--saveToNodeModules');
@@ -44,6 +65,13 @@ const outputDirs =
 const configPathArg = getArg('--config');
 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 log = (...args) => console.log(...args);
+const logDebug = (...args) => verboseArg && console.debug(chalk.gray.dim(...args));
+
 const findFederationConfig = (base) => {
     let files = fs.readdirSync(base);
     let queue = [];
@@ -63,21 +91,62 @@ const findFederationConfig = (base) => {
     }
 };
 
-if (configPath && !fs.existsSync(configPath)) {
-    console.error(`ERROR: Unable to find a provided config: ${configPath}`);
-    process.exit(1);
-}
+let federationConfig;
 
-const federationConfigPath = configPath || findFederationConfig('./');
+// Priority: inline config > --config > auto-find
+if (nameArg || exposesArgs.length > 0) {
+    // Inline config mode
+    if (!nameArg || exposesArgs.length === 0) {
+        console.error(
+            chalk.red('ERROR:'),
+            'Both --name and --exposes are required for inline config'
+        );
+        process.exit(1);
+    }
 
-if (federationConfigPath === undefined) {
-    console.error(`ERROR: Unable to find a federation.config.json file in this package`);
-    process.exit(1);
-}
+    if (configPath) {
+        console.warn(
+            chalk.yellow('WARNING:'),
+            'Both inline config and --config provided. Using inline config.'
+        );
+    }
+
+    const exposes = {};
+
+    exposesArgs.forEach(([key, value]) => {
+        // Normalize key - add ./ if missing
+        const normalizedKey = key.startsWith('./') ? key : `./${key}`;
+        exposes[normalizedKey] = value;
+    });
+
+    federationConfig = {
+        name: nameArg,
+        exposes: exposes,
+    };
+
+    log('Using inline config');
+    logDebug(JSON.stringify(federationConfig, null, 2));
+} else {
+    // File-based config (current behavior)
+    if (configPath && !fs.existsSync(configPath)) {
+        console.error(chalk.red('ERROR:'), `Unable to find a provided config: ${configPath}`);
+        process.exit(1);
+    }
 
-console.log(`Using config file: ${federationConfigPath}`);
+    const federationConfigPath = configPath || findFederationConfig('./');
+
+    if (federationConfigPath === undefined) {
+        console.error(
+            chalk.red('ERROR:'),
+            'Unable to find a federation.config.json file in this package'
+        );
+        process.exit(1);
+    }
+
+    log('Using config file', chalk.blue.bold(federationConfigPath));
+    federationConfig = require(federationConfigPath);
+}
 
-const federationConfig = require(federationConfigPath);
 const compileFiles = Object.values(federationConfig.exposes);
 const compileKeys = Object.keys(federationConfig.exposes);
 
@@ -87,6 +156,7 @@ function getModuleDeclareName(exposeName) {
 }
 
 try {
+    fs.mkdirSync(outputDir, { recursive: true });
     const outFile = path.resolve(outputDir, `${federationConfig.name}.d.ts`);
     if (fs.existsSync(outFile)) {
         fs.unlinkSync(outFile);
@@ -122,9 +192,10 @@ try {
 
     moduleNames.forEach((name) => {
         // exposeName - relative name of exposed component (if not found - just take moduleName)
-        const [exposeName = name, ...aliases] = compileKeys.filter((key) =>
-            federationConfig.exposes[key].endsWith(name)
-        );
+        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 moduleDeclareName = getModuleDeclareName(exposeName);
@@ -145,23 +216,23 @@ try {
     outputDirs.forEach((_outputDir) => {
         const _outFile = path.resolve(_outputDir, `${federationConfig.name}.d.ts`);
 
-        console.log('writing typing file:', _outFile);
+        logDebug('writing typing file:', _outFile);
         fs.mkdirSync(path.dirname(_outFile), { recursive: true });
         fs.writeFileSync(_outFile, typing);
 
-        console.debug(`using output dir: ${_outputDir}`);
+        logDebug(`using output dir: ${_outputDir}`);
         // if we are writing to the node_modules/@types directory, add a package.json file
         if (_outputDir.includes(path.join('node_modules', '@types'))) {
             const packageJsonPath = path.resolve(_outputDir, 'package.json');
 
             if (!fs.existsSync(packageJsonPath)) {
-                console.debug('writing package.json:', packageJsonPath);
+                logDebug('writing package.json:', packageJsonPath);
                 fs.copyFileSync(
                     path.resolve(__dirname, 'typings.package.tmpl.json'),
                     packageJsonPath
                 );
             } else {
-                console.debug(packageJsonPath, 'already exists');
+                logDebug(packageJsonPath, 'already exists');
             }
         }
 
@@ -170,18 +241,18 @@ try {
         const importStatement = `export * from './${federationConfig.name}';`;
 
         if (!fs.existsSync(indexPath)) {
-            console.log('creating index.d.ts file');
+            logDebug('creating index.d.ts file');
             fs.writeFileSync(indexPath, `${importStatement}\n`);
         } else {
-            console.log('updating index.d.ts file');
+            logDebug('updating index.d.ts file');
             const contents = fs.readFileSync(indexPath);
             if (!contents.includes(importStatement)) {
                 fs.writeFileSync(indexPath, `${contents}${importStatement}\n`);
             }
         }
     });
-    console.debug('Success!');
+    log(chalk.green('✓'), `Generated types for ${chalk.blue.bold(federationConfig.name)}`);
 } catch (e) {
-    console.error(`ERROR:`, e);
+    console.error(chalk.red('ERROR:'), e);
     process.exit(1);
 }

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.2.2-beta.1",
+    "version": "1.3.0-beta.2",
     "author": "Julian Wielga <j@touk.pl>",
     "bin": {
         "make-federated-types": "./cli.js"
@@ -10,6 +10,7 @@
         "Jonathan Greene <jgreene@pixability.com>"
     ],
     "dependencies": {
+        "chalk": "^4.1.2",
         "find-node-modules": "2.1.3"
     },
     "devDependencies": {