babel-plugin-transform-modules-ui5 7.9.0 → 7.11.0

package/CHANGELOG.md

@@ -1,5 +1,88 @@
 # Change Log
 
+## 7.11.0
+
+### Minor Changes
+
+- [#162](https://github.com/ui5-community/babel-plugin-transform-modules-ui5/pull/162) [`db2ad98`](https://github.com/ui5-community/babel-plugin-transform-modules-ui5/commit/db2ad98648ac7971d7b6cc1264b8d7b32d4b0b56) Thanks [@petermuessig](https://github.com/petermuessig)! - feat: auto-detect UI5 extend-classes by filename suffix and known base-class module paths
+
+  ## What's new
+  - **Auto-detection by known UI5 base classes**: Classes extending from known UI5 base-class module paths (e.g. `sap/ui/core/mvc/Controller`, `sap/ui/core/Control`, `sap/ui/base/ManagedObject`) are automatically converted to `.extend()` syntax without requiring explicit `@alias` or `@namespace` annotations. Controlled by new `autoConvertKnownUI5Classes` option (defaults to true).
+
+  - **Transitive inheritance resolution**: Auto-detection walks the superclass chain through local files (order-independent via on-demand ancestor reading from disk) and detects UI5 ancestry even through multiple levels of custom base classes.
+
+  - **File-type suffix detection**: New `autoConvertUI5FileTypes` option detects and converts classes based on filename patterns (`.controller.js|ts` and `.view.js|ts|jsx|tsx`). Controllers preserve legacy behavior (no namespace required). Views require a resolvable namespace.
+
+  - **Custom base-class paths**: New `additionalUI5Classes` option allows registering project-specific base-class module paths for auto-detection, supplementing the built-in UI5 class list.
+
+  - **Cycle detection**: Inheritance chain walking correctly handles cycles (A extends B extends A) via visited-set tracking instead of depth limits.
+
+  - **Watch-mode cache fixes**: Fixed stale cache entries persisting across rebuilds when files are renamed or deleted mid-watch. The `importDeclarations` cache entry is now cleared (not just overwritten) during re-processing.
+
+  - **Unmatched path warnings**: Added `console.warn` diagnostic when `additionalUI5Classes` paths are configured but never matched by any import in the build, helping catch typos and misconfigurations.
+
+  ## Breaking changes
+
+  None. All new features are opt-in or preserve existing behavior.
+
+  **Internal API note:** `getImportDeclaration` (in `src/classes/helpers/imports.js`) now matches
+  `import { Foo as Bar }` by the _local_ binding name (`Bar`) rather than the _imported_ name (`Foo`).
+  This is the correct semantics — callers always pass the name as it appears at the use site — but if
+  you maintain a fork or plugin that calls this helper directly by the imported name, update those call
+  sites to pass the local name instead.
+
+- [#168](https://github.com/ui5-community/babel-plugin-transform-modules-ui5/pull/168) [`e31c07f`](https://github.com/ui5-community/babel-plugin-transform-modules-ui5/commit/e31c07f2e47478ae77e00e135d60c4c8fb896c88) Thanks [@petermuessig](https://github.com/petermuessig)! - feat: add `@movePropsToConstructor` per-property annotation to opt out of `moveControllerPropsToOnInit` ([#116](https://github.com/ui5-community/babel-plugin-transform-modules-ui5/issues/116))
+
+  When `moveControllerPropsToOnInit` is enabled, individual class properties can be kept in the
+  constructor by annotating them with `@movePropsToConstructor` (JSDoc block comment or decorator):
+
+  ```ts
+  export default class MyController extends Controller {
+    /** Normal prop — moves to onInit as usual */
+    prop = 1;
+
+    /**
+     * @movePropsToConstructor
+     */
+    formatter = { formatValue: (v: string) => v }; // stays in constructor
+
+    handler = () => true; // moves to onInit as usual
+  }
+  ```
+
+### Patch Changes
+
+- [#167](https://github.com/ui5-community/babel-plugin-transform-modules-ui5/pull/167) [`d021d2e`](https://github.com/ui5-community/babel-plugin-transform-modules-ui5/commit/d021d2e6422494931ddeb8944ac443facc2c5e4b) Thanks [@petermuessig](https://github.com/petermuessig)! - fix: avoid crash when a default export uses `Object.assign(Object.create(null), …)` alongside named exports ([#148](https://github.com/ui5-community/babel-plugin-transform-modules-ui5/issues/148))
+
+  `getPropertiesOfObjectAssignOrExtendHelper` no longer leaks `undefined` entries for call-expression arguments
+  (e.g. `Object.create(null)`), which previously caused `Cannot read properties of undefined (reading 'key')` during
+  export collapsing.
+
+- [#166](https://github.com/ui5-community/babel-plugin-transform-modules-ui5/pull/166) [`506985d`](https://github.com/ui5-community/babel-plugin-transform-modules-ui5/commit/506985d2d5f9004faad9f4cbd9b5e4c04b4bd052) Thanks [@petermuessig](https://github.com/petermuessig)! - fix: handle string-literal import names and object property keys; escape regex metacharacters in noImportInteropPrefixes
+
+  Picks up the still-relevant fixes from PR [#163](https://github.com/ui5-community/babel-plugin-transform-modules-ui5/issues/163) (thanks @mauriciolauffer):
+
+  - Named imports using string-literal specifiers (`import { "some-export" as local } from "mod"`) now produce correct destructure output instead of `undefined`.
+  - `noImportInteropPrefixes` entries are now regex-escaped before being embedded in the regexp pattern, preventing metacharacters from acting as wildcards.
+  - `getPropNames` and `groupPropertiesByName` in `utils/ast.js` now handle `StringLiteral` property keys in addition to `Identifier` keys.
+
+## 7.10.0
+
+### Minor Changes
+
+- [#154](https://github.com/ui5-community/babel-plugin-transform-modules-ui5/pull/154) [`f62f9fb`](https://github.com/ui5-community/babel-plugin-transform-modules-ui5/commit/f62f9fba1a64dea2673662dd163fcc1eb5cff540) Thanks [@bbogovich-sap](https://github.com/bbogovich-sap)! - Add two comment pragmas to opt out of module transformation:
+
+  - `/* @ui5-no-wrap */` (file level) leaves a module completely unwrapped —
+    no `sap.ui.define`/`sap.ui.require` and no import/export rewriting — while
+    still stripping TypeScript types. Intended for modules consumed as native
+    ES modules, e.g. web workers.
+  - `/* @ui5-ignore-import */` (statement level) excludes a single static
+    `import` or dynamic `import()` from being converted into a UI5 dependency.
+
+  Note: `@ui5-ignore-import` on a static import only yields valid output in an
+  unwrapped module (no exports, or together with `@ui5-no-wrap`); a leftover
+  ES `import` inside a `sap.ui.define` factory is not valid at runtime.
+
 ## 7.9.0
 
 ### Minor Changes

package/dist/classes/helpers/classes.js

@@ -30,6 +30,7 @@ function convertClassToUI5Extend(path, node, classInfo, extraStaticProps, import
     return node;
   }
   const CONTROLLER_EXTENSION_TAG = "transformControllerExtension";
+  const KEEP_IN_CONSTRUCTOR_TAG = "movePropsToConstructor";
   const staticMembers = [];
   const classNameIdentifier = node.id;
   const className = classNameIdentifier.name;
@@ -42,6 +43,8 @@ function convertClassToUI5Extend(path, node, classInfo, extraStaticProps, import
   const alwaysMoveInstanceProps = !opts.onlyMoveClassPropsUsingThis;
   const extendProps = [];
   const boundProps = [];
+  const constructorBoundProps = []; // props that must stay in constructor even when moveControllerPropsToOnInit is true
+
   const CONSTRUCTOR = "constructor";
   const propsByName = {};
   let constructor;
@@ -187,6 +190,7 @@ function convertClassToUI5Extend(path, node, classInfo, extraStaticProps, import
           staticMembers.push(buildMemberAssignmentStatement(classNameIdentifier, member));
         }
       } else {
+        var _member$leadingCommen2, _member$decorators2;
         propsByName[memberName] = member.value;
         if (memberName === "constructor") {
           constructorComments = member.leadingComments;
@@ -195,8 +199,19 @@ function convertClassToUI5Extend(path, node, classInfo, extraStaticProps, import
             continue; // don't push to props yet
           }
         }
+        // When moveControllerPropsToOnInit is active, a per-property @movePropsToConstructor
+        // annotation (JSDoc block comment or decorator) opts that specific property out of the
+        // onInit move and keeps it in the constructor instead.
+        const keepInConstructor = moveControllerPropsToOnInit && (((_member$leadingCommen2 = member.leadingComments) === null || _member$leadingCommen2 === void 0 ? void 0 : _member$leadingCommen2.some(comment => comment.value.includes("@" + KEEP_IN_CONSTRUCTOR_TAG))) || ((_member$decorators2 = member.decorators) === null || _member$decorators2 === void 0 ? void 0 : _member$decorators2.some(decorator => {
+          var _decorator$expression2;
+          return ((_decorator$expression2 = decorator.expression) === null || _decorator$expression2 === void 0 ? void 0 : _decorator$expression2.name) === KEEP_IN_CONSTRUCTOR_TAG;
+        })));
         if (alwaysMoveInstanceProps || _core.types.isArrowFunctionExpression(member.value) || ast.isThisExpressionUsed(member.value)) {
-          boundProps.push(member);
+          if (keepInConstructor) {
+            constructorBoundProps.push(member);
+          } else {
+            boundProps.push(member);
+          }
         } else {
           extendProps.push(buildObjectProperty(member));
         }
@@ -249,6 +264,10 @@ function convertClassToUI5Extend(path, node, classInfo, extraStaticProps, import
   // See if we need either constructor or onInit
   const needsBindingMethod = boundProps.length || moveControllerPropsToOnInit && constructor && !keepConstructor;
 
+  // See if we need to create a constructor separately for constructorBoundProps
+  // (only relevant when moveControllerPropsToOnInit is on and some props opted out).
+  const needsConstructorForOverrides = moveControllerPropsToOnInit && constructorBoundProps.length;
+
   // See if we need to create a new 'constructor' or 'onInit' method, depending which one we'll bind to.
   if (needsBindingMethod && !bindMethod) {
     const bindToId = _core.types.identifier(bindToMethodName);
@@ -284,6 +303,32 @@ function convertClassToUI5Extend(path, node, classInfo, extraStaticProps, import
       bindMethod.body.body = [...upToSuper, ...mappedProps, ...afterSuper];
     }
   }
+  if (needsConstructorForOverrides) {
+    // Some props were annotated @movePropsToConstructor — inject them into the
+    // constructor even though moveControllerPropsToOnInit is active.
+    let constructorMethod = constructor;
+    if (!constructorMethod) {
+      // No explicit constructor: create an inheriting one and register it.
+      const constructorDeclaration = th.buildInheritingConstructor({
+        SUPER: _core.types.identifier(superClassName)
+      });
+      constructorMethod = ast.convertFunctionDeclarationToExpression(constructorDeclaration);
+      extendProps.unshift(_core.types.objectProperty(_core.types.identifier(CONSTRUCTOR), constructorMethod));
+    } else if (!keepConstructor) {
+      // Constructor exists but was merged into onInit — we need to keep it in
+      // extend() as well so the constructor-bound props have somewhere to live.
+      extendProps.unshift(_core.types.objectProperty(_core.types.identifier(CONSTRUCTOR), constructorMethod));
+    }
+    const mappedOverrideProps = constructorBoundProps.map(member => buildThisMemberAssignmentStatement(member));
+    const superIndex = constructorMethod.body.body.findIndex(node => ast.isSuperCallExpression(node.expression) || ast.isSuperPrototypeCallOf(node.expression, superClassName, CONSTRUCTOR));
+    if (superIndex === -1) {
+      constructorMethod.body.body.unshift(...mappedOverrideProps);
+    } else {
+      const upToSuper = constructorMethod.body.body.slice(0, superIndex + 1);
+      const afterSuper = constructorMethod.body.body.slice(superIndex + 1);
+      constructorMethod.body.body = [...upToSuper, ...mappedOverrideProps, ...afterSuper];
+    }
+  }
   const extendAssign = th.buildExtendAssign({
     NAME: classNameIdentifier,
     SUPER: superClass,
@@ -293,6 +338,16 @@ function convertClassToUI5Extend(path, node, classInfo, extraStaticProps, import
   });
   return [extendAssign, ...staticMembers];
 }
+
+/**
+ * Derives the fully-qualified name (FQN) passed to SAPClass.extend("FQN", ...).
+ *
+ * Precedence:
+ *   1. @alias  — full FQN set directly; use for named extend-classes (recommended)
+ *   2. @name   — full FQN set directly; use for anonymous class expressions where
+ *               @alias cannot be used (there is no local name to alias)
+ *   3. @namespace / fileNamespace — namespace prefix; the ES class name is appended
+ */
 function getFullyQualifiedName(classInfo) {
   if (classInfo.alias) return classInfo.alias;
   if (classInfo.name) return classInfo.name;
@@ -336,19 +391,7 @@ function getFileBaseNamespace(path, pluginOpts) {
   const opts = path.hub.file.opts;
   const filename = _path.default.resolve(opts.filename);
   const sourceRoot = opts.sourceRoot ? _path.default.resolve(process.cwd(), opts.sourceRoot) : process.cwd();
-  if (filename.startsWith(sourceRoot)) {
-    const filenameRelative = _path.default.relative(sourceRoot, filename);
-    const {
-      dir
-    } = _path.default.parse(filenameRelative);
-    const namespaceParts = dir.split(_path.default.sep);
-    if (pluginOpts.namespacePrefix) {
-      namespaceParts.unshift(pluginOpts.namespacePrefix);
-    }
-    return namespaceParts.join(".");
-  } else {
-    return undefined;
-  }
+  return (0, _imports.deriveNamespaceForFile)(filename, sourceRoot, pluginOpts);
 }
 const getQualifiedName = node => {
   let {

package/dist/classes/helpers/decorators.js

@@ -4,6 +4,17 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getDecoratorClassInfo = getDecoratorClassInfo;
+// Tags that provide a value for the class info via decorators.
+// The naming tags follow the same conventions as their JSDoc equivalents:
+//   @alias     — recommended for named UI5 extend-classes; sets the fully-qualified
+//               class name passed to .extend().
+//   @name      — use for anonymous (unnamed) class expressions where @alias cannot
+//               be used.
+//   @namespace — sets the namespace prefix; the ES class name is appended automatically
+//               to form the full FQN passed to .extend().
+// The following two are parsed but their values are not used by the class transformer;
+// metadata and renderer are handled via static class properties instead:
+//   @metadata, @renderer
 const classInfoValueTags = ["alias", "name", "namespace", "metadata", "renderer"];
 const classInfoBoolTags = ["nonUI5"];
 function getDecoratorClassInfo(node) {
@@ -31,10 +42,21 @@ function groupByName(decorators) {
   return decorators.reduce((accumulator, decorator) => {
     const expression = decorator.expression;
     const name = expression.name || expression.callee && expression.callee.name;
+    // Skip decorators with no resolvable name — e.g. member-expression decorators
+    // like `@foo.bar` / `@foo.bar()` (callee is a MemberExpression, so .name is
+    // undefined). These are never one of the recognised UI5 tags, and indexing with
+    // an undefined name would throw on .toLowerCase().
+    if (!name) {
+      return accumulator;
+    }
     accumulator[name.toLowerCase()] = decorator;
     return accumulator;
   }, {});
 }
 function getDecoratorValue(decorator) {
-  return (decorator && decorator.expression.arguments[0] || {}).value;
+  // A recognised value tag may be used without a call (e.g. `@alias` instead of
+  // `@alias("x")`). In that case decorator.expression is an Identifier with no
+  // `.arguments`, so guard before indexing to avoid a crash.
+  const args = decorator && decorator.expression && decorator.expression.arguments || [];
+  return (args[0] || {}).value;
 }