@nx/js 21.2.0-beta.4 → 21.2.0-beta.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "21.2.0-beta.4",
+  "version": "21.2.0-beta.5",
   "private": false,
   "description": "The JS plugin for Nx contains executors and generators that provide the best experience for developing JavaScript and TypeScript projects. ",
   "repository": {
@@ -39,8 +39,8 @@
     "@babel/preset-env": "^7.23.2",
     "@babel/preset-typescript": "^7.22.5",
     "@babel/runtime": "^7.22.6",
-    "@nx/devkit": "21.2.0-beta.4",
-    "@nx/workspace": "21.2.0-beta.4",
+    "@nx/devkit": "21.2.0-beta.5",
+    "@nx/workspace": "21.2.0-beta.5",
     "@zkochan/js-yaml": "0.0.7",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^3.1.0",

package/src/utils/typescript/__mocks__/function-after-declarations-plugin.d.ts

@@ -0,0 +1 @@
+export declare const afterDeclarations: (options: any, program: any) => () => void;

package/src/utils/typescript/__mocks__/function-after-declarations-plugin.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.afterDeclarations = void 0;
+const afterDeclarations = (options, program) => {
+    return () => { }; // Mock transformer factory
+};
+exports.afterDeclarations = afterDeclarations;

package/src/utils/typescript/__mocks__/function-after-plugin.d.ts

@@ -0,0 +1 @@
+export declare const after: (options: any, program: any) => () => void;

package/src/utils/typescript/__mocks__/function-after-plugin.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.after = void 0;
+const after = (options, program) => {
+    return () => { }; // Mock transformer factory
+};
+exports.after = after;

package/src/utils/typescript/__mocks__/function-direct-export.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (options: any, program: any) => () => void;
+export default _default;

package/src/utils/typescript/__mocks__/function-direct-export.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (options, program) => {
+    return () => { };
+};

package/src/utils/typescript/__mocks__/function-multiple-hooks.d.ts

@@ -0,0 +1,3 @@
+export declare const before: (options: any, program: any) => () => void;
+export declare const after: (options: any, program: any) => () => void;
+export declare const afterDeclarations: (options: any, program: any) => () => void;

package/src/utils/typescript/__mocks__/function-multiple-hooks.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.afterDeclarations = exports.after = exports.before = void 0;
+const before = (options, program) => {
+    return () => { }; // Mock transformer factory
+};
+exports.before = before;
+const after = (options, program) => {
+    return () => { }; // Mock transformer factory
+};
+exports.after = after;
+const afterDeclarations = (options, program) => {
+    return () => { }; // Mock transformer factory
+};
+exports.afterDeclarations = afterDeclarations;

package/src/utils/typescript/__mocks__/plugin-a.d.ts

@@ -1 +1 @@
-export declare const before: () => void;
+export declare const before: (options: any, program: any) => () => void;

package/src/utils/typescript/__mocks__/plugin-a.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.before = void 0;
-const before = () => { };
+const before = (options, program) => {
+    return () => { }; // Mock transformer factory
+};
 exports.before = before;

package/src/utils/typescript/__mocks__/plugin-b.d.ts

@@ -1 +1 @@
-export declare const after: () => void;
+export declare const after: (options: any, program: any) => () => void;

package/src/utils/typescript/__mocks__/plugin-b.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.after = void 0;
-const after = () => { };
+const after = (options, program) => {
+    return () => { }; // Mock transformer factory
+};
 exports.after = after;

package/src/utils/typescript/load-ts-transformers.js

@@ -3,6 +3,54 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadTsTransformers = loadTsTransformers;
 const devkit_1 = require("@nx/devkit");
 const path_1 = require("path");
+var TransformerFormat;
+(function (TransformerFormat) {
+    TransformerFormat[TransformerFormat["STANDARD"] = 0] = "STANDARD";
+    TransformerFormat[TransformerFormat["FUNCTION_EXPORT"] = 1] = "FUNCTION_EXPORT";
+    TransformerFormat[TransformerFormat["UNKNOWN"] = 2] = "UNKNOWN";
+})(TransformerFormat || (TransformerFormat = {}));
+function detectTransformerFormat(plugin) {
+    // Check if it's a standard Nx/TypeScript transformer plugin
+    if (plugin && (plugin.before || plugin.after || plugin.afterDeclarations)) {
+        return TransformerFormat.STANDARD;
+    }
+    // Check if it's a function-based transformer (exports a function directly)
+    if (typeof plugin === 'function') {
+        return TransformerFormat.FUNCTION_EXPORT;
+    }
+    // Check if it has a function export (function-based plugin pattern)
+    if (plugin &&
+        (typeof plugin.before === 'function' ||
+            typeof plugin.after === 'function' ||
+            typeof plugin.afterDeclarations === 'function')) {
+        return TransformerFormat.FUNCTION_EXPORT;
+    }
+    return TransformerFormat.UNKNOWN;
+}
+function adaptFunctionBasedTransformer(plugin, pluginOptions) {
+    // Handle direct function export
+    if (typeof plugin === 'function') {
+        return {
+            before: (options, program) => plugin(options, program),
+        };
+    }
+    // Handle object with function exports - adapt all available hooks
+    if (plugin && typeof plugin === 'object') {
+        const adapted = {};
+        if (typeof plugin.before === 'function') {
+            adapted.before = (options, program) => plugin.before(options, program);
+        }
+        if (typeof plugin.after === 'function') {
+            adapted.after = (options, program) => plugin.after(options, program);
+        }
+        if (typeof plugin.afterDeclarations === 'function') {
+            adapted.afterDeclarations = (options, program) => plugin.afterDeclarations(options, program);
+        }
+        // Return adapted hooks if any were found, otherwise return original plugin
+        return Object.keys(adapted).length > 0 ? adapted : plugin;
+    }
+    return plugin;
+}
 function loadTsTransformers(plugins, moduleResolver = require.resolve) {
     const beforeHooks = [];
     const afterHooks = [];
@@ -26,7 +74,16 @@ function loadTsTransformers(plugins, moduleResolver = require.resolve) {
             const binaryPath = moduleResolver(name, {
                 paths: nodeModulePaths,
             });
-            return require(binaryPath);
+            const loadedPlugin = require(binaryPath);
+            // Check if main export already has transformer hooks
+            if (loadedPlugin &&
+                (loadedPlugin.before ||
+                    loadedPlugin.after ||
+                    loadedPlugin.afterDeclarations)) {
+                return loadedPlugin;
+            }
+            // Only fall back to .default if main export lacks transformer hooks
+            return loadedPlugin?.default ?? loadedPlugin;
         }
         catch (e) {
             devkit_1.logger.warn(`"${name}" plugin could not be found!`);
@@ -35,19 +92,53 @@ function loadTsTransformers(plugins, moduleResolver = require.resolve) {
     });
     for (let i = 0; i < pluginRefs.length; i++) {
         const { name: pluginName, options: pluginOptions } = normalizedPlugins[i];
-        const { before, after, afterDeclarations } = pluginRefs[i];
+        let plugin = pluginRefs[i];
+        // Skip empty plugins (failed to load)
+        if (!plugin ||
+            (typeof plugin !== 'function' && Object.keys(plugin).length === 0)) {
+            continue;
+        }
+        const format = detectTransformerFormat(plugin);
+        // Adapt function-based transformers to standard format
+        if (format === TransformerFormat.FUNCTION_EXPORT) {
+            devkit_1.logger.debug(`Adapting function-based transformer: ${pluginName}`);
+            plugin = adaptFunctionBasedTransformer(plugin, pluginOptions);
+        }
+        else if (format === TransformerFormat.UNKNOWN) {
+            devkit_1.logger.warn(`${pluginName} is not a recognized Transformer Plugin format. It should export ` +
+                `{ before?, after?, afterDeclarations? } functions or be a function-based transformer.`);
+            continue;
+        }
+        const { before, after, afterDeclarations } = plugin;
+        // Validate that at least one hook is available
         if (!before && !after && !afterDeclarations) {
-            devkit_1.logger.warn(`${pluginName} is not a Transformer Plugin. It does not provide neither before(), after(), nor afterDeclarations()`);
+            devkit_1.logger.warn(`${pluginName} does not provide any transformer hooks (before, after, or afterDeclarations).`);
             continue;
         }
+        // Add hooks with proper error handling
         if (before) {
-            beforeHooks.push(before.bind(before, pluginOptions));
+            try {
+                beforeHooks.push((program) => before(pluginOptions, program));
+            }
+            catch (error) {
+                devkit_1.logger.error(`Failed to register 'before' transformer for ${pluginName}: ${error.message}`);
+            }
         }
         if (after) {
-            afterHooks.push(after.bind(after, pluginOptions));
+            try {
+                afterHooks.push((program) => after(pluginOptions, program));
+            }
+            catch (error) {
+                devkit_1.logger.error(`Failed to register 'after' transformer for ${pluginName}: ${error.message}`);
+            }
         }
         if (afterDeclarations) {
-            afterDeclarationsHooks.push(afterDeclarations.bind(afterDeclarations, pluginOptions));
+            try {
+                afterDeclarationsHooks.push((program) => afterDeclarations(pluginOptions, program));
+            }
+            catch (error) {
+                devkit_1.logger.error(`Failed to register 'afterDeclarations' transformer for ${pluginName}: ${error.message}`);
+            }
         }
     }
     return {

package/src/utils/typescript/types.d.ts

@@ -10,6 +10,17 @@ export interface CompilerPlugin {
     after?: (options?: Record<string, unknown>, program?: Program) => TransformerFactory;
     afterDeclarations?: (options?: Record<string, unknown>, program?: Program) => TransformerFactory;
 }
+/**
+ * Extended plugin interface to support different transformer API formats
+ * including function-based transformers and direct function exports
+ */
+export type AnyCompilerPlugin = CompilerPlugin | ((options?: Record<string, unknown>, program?: Program) => TransformerFactory) | {
+    before: (options?: Record<string, unknown>, program?: Program) => TransformerFactory;
+} | {
+    after: (options?: Record<string, unknown>, program?: Program) => TransformerFactory;
+} | {
+    afterDeclarations: (options?: Record<string, unknown>, program?: Program) => TransformerFactory;
+};
 export interface CompilerPluginHooks {
     beforeHooks: Array<(program?: Program) => TransformerFactory>;
     afterHooks: Array<(program?: Program) => TransformerFactory>;