@eclipse-scout/cli 25.1.16-alpha.1 → 25.2.0-beta.0

package/README.md

@@ -3,8 +3,8 @@
 </p>
 
 <p align="center">
-  <a href="https://ci.eclipse.org/scout/job/scout-integration-25.1-RT-nightly_pipeline/" target="_blank" rel="noopener noreferrer"><img alt="Jenkins" src="https://img.shields.io/jenkins/build?jobUrl=https%3A%2F%2Fci.eclipse.org%2Fscout%2Fjob%2Fscout-integration-25.1-RT-nightly_pipeline%2F"></a>
-  <a href="https://ci.eclipse.org/scout/job/scout-integration-25.1-RT-nightly_pipeline/" target="_blank" rel="noopener noreferrer"><img alt="Jenkins tests" src="https://img.shields.io/jenkins/tests?jobUrl=https%3A%2F%2Fci.eclipse.org%2Fscout%2Fjob%2Fscout-integration-25.1-RT-nightly_pipeline%2F"></a>
+  <a href="https://ci.eclipse.org/scout/job/scout-integration-25.2-RT-nightly_pipeline/" target="_blank" rel="noopener noreferrer"><img alt="Jenkins" src="https://img.shields.io/jenkins/build?jobUrl=https%3A%2F%2Fci.eclipse.org%2Fscout%2Fjob%2Fscout-integration-25.2-RT-nightly_pipeline%2F"></a>
+  <a href="https://ci.eclipse.org/scout/job/scout-integration-25.2-RT-nightly_pipeline/" target="_blank" rel="noopener noreferrer"><img alt="Jenkins tests" src="https://img.shields.io/jenkins/tests?jobUrl=https%3A%2F%2Fci.eclipse.org%2Fscout%2Fjob%2Fscout-integration-25.2-RT-nightly_pipeline%2F"></a>
   <a href="https://www.npmjs.com/package/@eclipse-scout/cli" target="_blank" rel="noopener noreferrer"><img alt="npm" src="https://img.shields.io/npm/dm/@eclipse-scout/cli"></a>
   <a href="https://www.eclipse.org/legal/epl-2.0/" target="_blank" rel="noopener noreferrer"><img alt="NPM" src="https://img.shields.io/npm/l/@eclipse-scout/cli"></a>
   <a href="https://www.npmjs.com/package/@eclipse-scout/cli" target="_blank" rel="noopener noreferrer"><img alt="npm (scoped)" src="https://img.shields.io/npm/v/@eclipse-scout/cli"></a>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eclipse-scout/cli",
-  "version": "25.1.16-alpha.1",
+  "version": "25.2.0-beta.0",
   "description": "CLI for Eclipse Scout",
   "author": "BSI Business Systems Integration AG",
   "homepage": "https://eclipse.dev/scout/",
@@ -45,8 +45,8 @@
     "karma-jasmine": "5.1.0",
     "karma-jasmine-ajax": "0.1.13",
     "@metahub/karma-jasmine-jquery": "4.0.1",
-    "@eclipse-scout/karma-jasmine-scout": "25.1.16-alpha.1",
-    "@eclipse-scout/tsconfig": "25.1.16-alpha.1",
+    "@eclipse-scout/karma-jasmine-scout": "25.2.0-beta.0",
+    "@eclipse-scout/tsconfig": "25.2.0-beta.0",
     "karma-jasmine-html-reporter": "2.1.0",
     "karma-junit-reporter": "2.0.1",
     "karma-webpack": "5.0.1",
@@ -72,6 +72,7 @@
     "version:snapshot:dependencies": "releng-scripts version:snapshot:dependencies",
     "version:snapshot": "releng-scripts version:snapshot",
     "version:release:dependencies": "releng-scripts version:release:dependencies",
-    "version:release": "releng-scripts version:release"
+    "version:release": "releng-scripts version:release",
+    "test": "node test/runTests.js"
   }
 }

package/scripts/DataObjectTransformer.js

@@ -0,0 +1,293 @@
+/*
+ * Copyright (c) 2010, 2025 BSI Business Systems Integration AG
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
+const ts = require('typescript');
+const ModuleDetector = require('./ModuleDetector');
+const CONSTANT_PATTERN = new RegExp('^[A-Z_0-9]+$');
+
+/**
+ * TypeScript transformer for DataObject which injects @Reflect.metadata('scout.m.t', dataType) decorators to all DO attributes.
+ * These decorators store the data type information from the TS property declaration.
+ * This allows to transfer the TypeScript data type information to the runtime which is used when (de)serializing a data object.
+ *
+ * See https://github.com/itsdouges/typescript-transformer-handbook
+ */
+module.exports = class DataObjectTransformer {
+
+  constructor(program, context, namespaceResolver) {
+    this.program = program;
+    this.context = context;
+    this.moduleDetector = null; // created on first use
+    this.doInventoryAddStatements = [];
+    this.namespaceResolver = namespaceResolver;
+  }
+
+  transform(node) {
+    if (ts.isSourceFile(node)) {
+      let transformedFile = this._visitChildren(node); // step into top level source files
+      if (this.doInventoryAddStatements.length) {
+        // add auto-register DO statements to the source file end
+        const statements = [...transformedFile.statements, ...this.doInventoryAddStatements];
+        transformedFile = ts.factory.updateSourceFile(node, statements,
+          transformedFile.isDeclarationFile, transformedFile.referencedFiles, transformedFile.typeReferenceDirectives, transformedFile.hasNoDefaultLib, transformedFile.libReferenceDirectives);
+        this.doInventoryAddStatements = []; // clear added statements
+      }
+      this.moduleDetector = null; // forget cached types for this file
+      return transformedFile;
+    }
+    if (ts.isClassDeclaration(node)) {
+      const typeNameDecorator = node.modifiers?.find(m => ts.isDecorator(m) && m.expression?.expression?.escapedText === 'typeName');
+      if (typeNameDecorator) {
+        // it is a data object: remember DataObjectInventory.add statement to add at the end to the source file
+        const className = node.localSymbol.escapedName;
+        const typeName = this._getTypeNameFromDecorator(typeNameDecorator);
+        const namespace = this._detectExportInfoFor(node).namespace; // detectExportInfoOf() will not find anything because a ClassDeclaration node is passed here. But this is fine as the namespace of the own module is required here.
+        this.doInventoryAddStatements.push(this._createDoInventoryAddStatement(className, typeName, namespace));
+        return this._visitChildren(node); // step into DO with typeName decorator
+      }
+      return node; // no need to step into
+    }
+    if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node) || ts.isVariableStatement(node) || ts.isIdentifier(node) || ts.isTypeReferenceNode(node)
+      || ts.isPropertySignature(node) || ts.isStringLiteral(node) || ts.isInterfaceDeclaration(node) || ts.isPropertyAssignment(node) || ts.isObjectLiteralExpression(node)
+      || ts.isPropertyAccessExpression(node) || ts.isTypeAliasDeclaration(node) || ts.isParameter(node) || ts.isEnumDeclaration(node)
+      || ts.isCallExpression(node) || ts.isExpressionStatement(node) || ts.isDecorator(node) || node.kind === ts.SyntaxKind.ExportKeyword) {
+      return node; // no need to step into
+    }
+
+    if (ts.isPropertyDeclaration(node) && !this._isSkipProperty(node)) {
+      const newModifiers = [
+        ...(node.modifiers || []), // existing
+        ...this._createMetaDataDecoratorsFor(node) // newly added
+      ];
+      return ts.factory.replaceDecoratorsAndModifiers(node, newModifiers);
+    }
+    return node; // no need to step into
+  }
+
+  /**
+   * Reads the value passed to the typeName decorator. Supports direct string literals and references to constants
+   * @param typeNameDecorator {ts.Decorator}
+   * @returns {string|null}
+   */
+  _getTypeNameFromDecorator(typeNameDecorator) {
+    const decoratorArgument = typeNameDecorator.expression?.arguments?.[0];
+    if (decoratorArgument && ts.isStringLiteral(decoratorArgument)) {
+      return decoratorArgument.text;
+    }
+
+    // might be a reference to a constant
+    let constant = decoratorArgument?.flowNode?.node;
+    if (constant && ts.isVariableDeclaration(constant)) {
+      const initializer = constant.initializer;
+      if (initializer && ts.isStringLiteral(initializer)) {
+        return initializer.text;
+      }
+    }
+
+    return null; // rely on the auto-detection of the Scout RT.
+  }
+
+  /**
+   * @param node {ts.PropertyDeclaration} the node for the DO property.
+   * @returns {ts.Decorator[]}
+   */
+  _createMetaDataDecoratorsFor(node) {
+    if (!node.type) {
+      return [];
+    }
+    return [this._createMetaDataDecorator(this._createTypeNode(node.type))];
+  }
+
+  /**
+   * Creates the value node to be added to the @Reflect.metadata('scout.m.t', valueNode) decorator.
+   * @param typeNode {ts.TypeNode} The data type node of a DO property.
+   * @returns {ts.StringLiteral|ts.Identifier|ts.ObjectLiteralExpression}
+   *   A constructor reference identifier for primitives like number, string, boolean, object, unknown, any, void, etc.
+   *   A constructor reference identifier for built-in types like Map, Set, Date.
+   *   A RawFieldMetaData object literal for arrays (having Array type and the element type as type arguments: Array<ElementType>).
+   *   A string literal for string literal types as e.g. used in IDs: UuId<'scout.SimpleUuid'>.
+   *   A string literal for custom type references not having type arguments in the form of a Scout objectType: 'myApp.MySpecialDo'.
+   *   A RawFieldMetaData object literal for type references having type arguments.
+   */
+  _createTypeNode(typeNode) {
+    if (typeNode.kind === ts.SyntaxKind.NumberKeyword) {
+      // primitive number
+      return ts.factory.createIdentifier('Number');
+    }
+    if (typeNode.kind === ts.SyntaxKind.StringKeyword) {
+      // primitive string
+      return ts.factory.createIdentifier('String');
+    }
+    if (typeNode.kind === ts.SyntaxKind.BooleanKeyword) {
+      // primitive boolean
+      return ts.factory.createIdentifier('Boolean');
+    }
+    // bigint is not yet supported as it is only part of ES2020 while Scout still uses ES2019
+
+    if (ts.isArrayTypeNode(typeNode)) {
+      // treat Obj[] like Array<Obj>
+      const objectType = ts.factory.createIdentifier('Array');
+      const elementType = this._createTypeNode(typeNode.elementType);
+      return this._createFieldMetaData(objectType, [elementType]);
+    }
+
+    if (ts.isTypeReferenceNode(typeNode)) {
+      const objectType = this._createTypeReferenceNode(typeNode);
+      if (!typeNode.typeArguments?.length) {
+        // no type arguments: directly use the type reference (constructor ref or objectType string)
+        return objectType;
+      }
+
+      // types with typeArguments like Map<string, number> or Array<MyObject>
+      const typeArgsNodes = typeNode.typeArguments.map(typeArg => this._createTypeNode(typeArg));
+      return this._createFieldMetaData(objectType, typeArgsNodes);
+    }
+
+    // // literal types like e.g. in IDs: UuId<'scout.SimpleUuid'>
+    if (ts.isLiteralTypeNode(typeNode)) {
+      if (ts.isStringLiteral(typeNode.literal)) {
+        return ts.factory.createStringLiteral(typeNode.literal.text);
+      }
+    }
+
+    return ts.factory.createIdentifier('Object'); // e.g. any, void, unknown
+  }
+
+  /**
+   * Creates a field metadata object. See RawFieldMetaData type.
+   * <pre>
+   *   {
+   *     objectType: 'myApp.MySpecialDo',
+   *     typeArgs: [...]
+   *   }
+   * </pre>
+   * @returns {ts.ObjectLiteralExpression}
+   */
+  _createFieldMetaData(objectType, typeArgsNodes) {
+    return ts.factory.createObjectLiteralExpression([
+      ts.factory.createPropertyAssignment('objectType', objectType),
+      ts.factory.createPropertyAssignment('typeArgs', ts.factory.createArrayLiteralExpression(typeArgsNodes, false))
+    ], false);
+  }
+
+  /**
+   * Creates a node for a type reference.
+   *
+   * This is directly the constructor reference for built-in types like Date, Number, String, Map, Set, etc.
+   * Or a string with the Scout objectType for the type (e.g. 'myApp.MySpecialDo').
+   *
+   * @param node {ts.TypeReferenceNode}
+   * @returns {ts.StringLiteral|ts.Identifier}
+   */
+  _createTypeReferenceNode(node) {
+    const name = node.typeName.escapedText;
+    if (global[name]) {
+      return ts.factory.createIdentifier(name); // Use directly the constructor for known types like Date, Number, String, Boolean, Map, Set, Array
+    }
+    if ('Record' === name) {
+      return ts.factory.createStringLiteral(name);
+    }
+
+    const exportInfo = this._detectExportInfoFor(node);
+    const qualifiedName = this._createObjectType(exportInfo.namespace, exportInfo.exportName);
+    // use objectType as string because e.g. of TS interfaces (which do not exist at RT) and that overwrites in ObjectFactory are taken into account.
+    return ts.factory.createStringLiteral(qualifiedName);
+  }
+
+  /**
+   * Creates the qualified object type (e.g. 'myApp.MyDataObject').
+   * @param namespace {string} the namespace of the class
+   * @param className {string} the name of the class
+   * @returns {string} The objectType
+   */
+  _createObjectType(namespace, className) {
+    return (!namespace || namespace === 'scout') ? className : namespace + '.' + className;
+  }
+
+  /**
+   * 1. Checks in which Node module the type referenced by typeNode is declared.
+   * 2. Resolves the Scout JS namespace and exported name of the referenced type.
+   *
+   * @param typeNode {ts.TypeReferenceNode} The type reference for which the namespace it is declared in should be resolved.
+   * @returns {{namespace: string|null;exportName: string|null}} The namespace of the module that contains the given type.
+   */
+  _detectExportInfoFor(typeNode) {
+    if (!this.moduleDetector) {
+      this.moduleDetector = new ModuleDetector(typeNode);
+    }
+    const exportInfo = this.moduleDetector.detectExportInfoOf(typeNode);
+    const namespace = this.namespaceResolver.resolveNamespace(exportInfo?.module, this.moduleDetector.sourceFile.fileName);
+    return {namespace, exportName: exportInfo?.exportName || typeNode?.typeName?.escapedText};
+  }
+
+  /**
+   * Creates a metadata decorator:
+   * <pre>
+   *   @Reflect.metadata('scout.m.t', valueNode)
+   * </pre>
+   * @param valueNode The value of the decorator.
+   * @returns {ts.Decorator}
+   */
+  _createMetaDataDecorator(valueNode) {
+    const reflect = ts.factory.createIdentifier('Reflect');
+    const reflectMetaData = ts.factory.createPropertyAccessExpression(reflect, ts.factory.createIdentifier('metadata'));
+    const keyNode = ts.factory.createStringLiteral('scout.m.t');
+    const call = ts.factory.createCallExpression(reflectMetaData, undefined, [keyNode, valueNode]);
+    return ts.factory.createDecorator(call);
+  }
+
+  /**
+   * Skips properties which are static, protected or the name starts with '$' or '_'.
+   * Furthermore, constant like properties (consisting of uppercase chars, numbers and underscore) are skipped as well.
+   * @returns {boolean}
+   */
+  _isSkipProperty(node) {
+    const propertyName = node.symbol?.escapedName;
+    if (!propertyName || propertyName.startsWith('_') || propertyName.startsWith('$') || CONSTANT_PATTERN.test(propertyName)) {
+      return true;
+    }
+    return !!node.modifiers?.some(n => n.kind === ts.SyntaxKind.StaticKeyword || n.kind === ts.SyntaxKind.ProtectedKeyword);
+  }
+
+  _visitChildren(node) {
+    return ts.visitEachChild(node, n => this.transform(n), this.context);
+  }
+
+  /**
+   * Creates an ExpressionStatement calling DataObjectInventory.add for the given data object name.
+   * Creates the following call:
+   * <pre>
+   * window['scout']['DataObjectInventory'].get().add(className, typeName, objectType);
+   * </pre>
+   * @param className {string} The local class name of the data object.
+   * @param typeName {string|null} The typeName value of the data object (as detected from the @typeName decorator)
+   * @param namespace {string|null} The namespace of the current module. Used to build the objectType of the class.
+   * @returns {ts.ExpressionStatement}
+   */
+  _createDoInventoryAddStatement(className, typeName, namespace) {
+    if (!className) {
+      throw new Error('DataObjectInventory.add not supported for anonymous data objects.');
+    }
+    const win = ts.factory.createIdentifier('window');
+    const scout = ts.factory.createElementAccessExpression(win, ts.factory.createStringLiteral('scout'));
+    const doInventory = ts.factory.createElementAccessExpression(scout, ts.factory.createStringLiteral('DataObjectInventory'));
+    const get = ts.factory.createPropertyAccessExpression(doInventory, 'get');
+    const getCall = ts.factory.createCallExpression(get, undefined, undefined);
+    const add = ts.factory.createPropertyAccessExpression(getCall, 'add');
+
+    const objectType = this._createObjectType(namespace, className);
+    const addCall = ts.factory.createCallExpression(add, undefined, [
+      ts.factory.createIdentifier(className),
+      typeName ? ts.factory.createStringLiteral(typeName) : ts.factory.createNull(),
+      ts.factory.createStringLiteral(objectType)
+    ]);
+    return ts.factory.createExpressionStatement(addCall);
+  }
+};

package/scripts/ModuleDetector.js

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2010, 2025 BSI Business Systems Integration AG
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
+const ts = require('typescript');
+
+/**
+ * Class to compute the external module name (e.g. '@eclipse-scout/core') of types used in the TS file given.
+ *
+ * It parses all imports in the file and stores all names imported from external modules together with the module the name is declared in.
+ * External module means an import from a module different from the one this files belongs to.
+ */
+module.exports = class ModuleDetector {
+
+  /**
+   * @param node A node in the TS file for which the module detector should be created. All external modules used (imported) in this file are stored.
+   */
+  constructor(node) {
+    this.sourceFile = this._findSourceFile(node);
+    const imports = this._findImportDeclarations(this.sourceFile);
+    this._moduleByTypeMap = this._computeImportMap(imports); // Map only contains types in 'other' modules (modules different from the one of the source file)
+  }
+
+  /**
+   * @param typeNode {ts.TypeReferenceNode}
+   * @returns {{module: string;exportName:string}} The name of the module (e.g. '@eclipse-scout/core') the given type is declared in and the name it was exported in this module.
+   * Only returns a value if it is a different module than the one this detector was created in (only external modules).
+   * For imports in the same module, this function returns undefined.
+   */
+  detectExportInfoOf(typeNode) {
+    const name = typeNode?.typeName?.escapedText;
+    return this._moduleByTypeMap.get(name);
+  }
+
+  _computeImportMap(imports) {
+    const moduleByTypeMap = new Map();
+    for (let imp of imports) {
+      const moduleName = imp.moduleSpecifier?.text; // e.g. '@eclipse-scout/core' or './index'
+      const isExternalModule = !moduleName?.startsWith('.'); // only store imports to other modules
+      if (isExternalModule) {
+        this._putExternalNamedBindings(imp.importClause?.namedBindings, moduleByTypeMap, moduleName);
+      }
+    }
+    return moduleByTypeMap;
+  }
+
+  _putExternalNamedBindings(namedBindings, moduleByTypeMap, moduleName) {
+    const importElements = namedBindings?.elements;
+    if (Array.isArray(importElements)) {
+      // multi import e.g.: import {a, b, c as d} from 'whatever'
+      for (let importElement of importElements) {
+        const name = importElement?.name?.escapedText;
+        if (!name) {
+          continue;
+        }
+        const exportedName = importElement?.propertyName?.escapedText || name;
+        moduleByTypeMap.set(name, {module: moduleName, exportName: exportedName});
+      }
+    } else {
+      // single import e.g.: import * as self from './index';
+      const name = namedBindings?.name?.escapedText;
+      if (name) {
+        moduleByTypeMap.set(name, {module: moduleName, exportName: name});
+      }
+    }
+  }
+
+  _findImportDeclarations(sourceFile) {
+    return sourceFile.statements.filter(s => ts.isImportDeclaration(s));
+  }
+
+  _findSourceFile(node) {
+    while (!ts.isSourceFile(node)) {
+      node = node.parent;
+    }
+    return node;
+  }
+};

package/scripts/ModuleNamespaceResolver.js

@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 2010, 2025 BSI Business Systems Integration AG
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+
+const fs = require('fs');
+const path = require('path');
+const REGISTER_NS_PATTERN = new RegExp('\\.registerNamespace\\s*\\(\'(\\w+)\'\\s*,');
+const JS_COMMENTS_PATTERN = new RegExp('\\/\\*[\\s\\S]*?\\*\\/|(?<=[^:])\\/\\/.*|^\\/\\/.*', 'g');
+
+/**
+ * Class to resolve the Scout JS namespace of a module (e.g. module 'eclipse-scout/core' uses namespace 'scout').
+ */
+module.exports = class ModuleNamespaceResolver {
+
+  constructor() {
+    this._rootsByFileDir = new Map();
+    this._namespaceByModuleRoot = new Map();
+    this._dependencyRootsByModuleRoot = new Set();
+    this.ownModuleNamespace = null;
+  }
+
+  /**
+   * Resolves the Scout JS namespace for the given module name.
+   *
+   * Algorithm:
+   * 1. It resolves the module root of the sourceFilePath given (the first parent directory containing the package.json file).
+   * 2. If a moduleName is given searches for a dependency in node_modules with given moduleName and uses its module root.
+   * 3. Searches in the module for a file *.js or *.ts file calling the Scout method 'registerNamespace' and uses the value passed as namespace.
+   *
+   * @param moduleName {string} The name of an external dependency module (e.g. '@eclipse-scout/core') or null if the namespace of the module containing the sourceFilePath should be returned.
+   * @param sourceFilePath {string} A file path inside a module that has a dependency to the moduleName (if available).
+   * @returns {string} The namespace or undefined.
+   */
+  resolveNamespace(moduleName, sourceFilePath) {
+    const moduleRoot = this.resolveModuleRoot(moduleName, sourceFilePath);
+    let namespace = this._namespaceByModuleRoot.get(moduleRoot);
+    if (!namespace) {
+      if (!moduleName && this.ownModuleNamespace) {
+        // use given namespace for own module if known
+        namespace = this.ownModuleNamespace;
+      } else {
+        namespace = this._resolveNamespace(moduleRoot);
+      }
+      this._namespaceByModuleRoot.set(moduleRoot, namespace);
+    }
+    return namespace;
+  }
+
+  /**
+   * @param moduleRoot {string}
+   * @returns {string}
+   */
+  _resolveNamespace(moduleRoot) {
+    let searchRoot = moduleRoot;
+    const srcFolder = path.join(moduleRoot, 'src');
+    if (fs.existsSync(srcFolder)) {
+      searchRoot = srcFolder;
+      const mavenSrc = path.join(searchRoot, 'main/js');
+      if (fs.existsSync(mavenSrc)) {
+        searchRoot = mavenSrc;
+      }
+    }
+    return this._parseFromRegister(searchRoot);
+  }
+
+  /**
+   * @param root {string}
+   * @returns {string} The namespace parsed from the 'registerNamespace' function.
+   */
+  _parseFromRegister(root) {
+    let namespace = null;
+    this._visitFiles(root, filePath => {
+      const content = fs.readFileSync(filePath, 'utf-8').toString();
+      const result = REGISTER_NS_PATTERN.exec(content.replaceAll(JS_COMMENTS_PATTERN, ''));
+      if (result?.length === 2) {
+        namespace = result[1];
+        return false; // abort
+      }
+      return true;
+    });
+    return namespace;
+  }
+
+  /**
+   * Breadth-first visit of all *.ts or *.ts files within the given root directory excluding node_modules sub folders.
+   * @param root {string} The root directory path
+   * @param callback {(string) => boolean} Callback for all *.ts or *.js file paths in given directory. Visiting is aborted as soon as the callback returns false.
+   */
+  _visitFiles(root, callback) {
+    const buf = this._readDir(root);
+    while (buf.length) {
+      const dirent = buf.shift(); // remove first
+      const filePath = path.join(dirent.parentPath || dirent.path, dirent.name);
+      if (dirent.isFile()) {
+        const cont = callback(filePath);
+        if (!cont) {
+          return;
+        }
+      } else {
+        buf.push(...this._readDir(filePath));
+      }
+    }
+  }
+
+  /**
+   * @param directory {string} The directory to get the contents from
+   * @returns {Dirent[]} Array of child files (only *.js or *.ts) or folders (excluding node_modules)
+   */
+  _readDir(directory) {
+    return fs.readdirSync(directory, {withFileTypes: true})
+      .filter(dirent => (dirent.isDirectory() && dirent.name !== 'node_modules') || dirent.name.endsWith('.js') || dirent.name.endsWith('.ts'))
+      .sort((a, b) => { // files first
+        if (a.isDirectory() && !b.isDirectory()) {
+          return 1;
+        }
+        if (!a.isDirectory() && b.isDirectory()) {
+          return -1;
+        }
+        return a.name.localeCompare(b.name);
+      });
+  }
+
+  resolveModuleRoot(moduleName, sourceFilePath) {
+    const directory = path.dirname(sourceFilePath);
+    const moduleRoot = this._getModuleRoot(directory);
+    if (!moduleName) {
+      return moduleRoot; // no external module name: own module
+    }
+    return this._resolveExternalModule(moduleRoot, moduleName);
+  }
+
+  /**
+   * @param moduleRoot {string}
+   * @param moduleName {string}
+   * @returns {string}
+   */
+  _resolveExternalModule(moduleRoot, moduleName) {
+    const dependencyRoot = path.join(moduleRoot, 'node_modules', moduleName);
+    if (this._dependencyRootsByModuleRoot.has(dependencyRoot)) {
+      return dependencyRoot; // existence already verified
+    }
+
+    if (!fs.existsSync(path.join(dependencyRoot, 'package.json'))) {
+      throw new Error(`Dependency ${moduleName} not found in ${moduleRoot}.`);
+    }
+    this._dependencyRootsByModuleRoot.add(dependencyRoot);
+    return dependencyRoot;
+  }
+
+  /**
+   *
+   * @param sourceFileDir {string}
+   * @returns {string}
+   */
+  _getModuleRoot(sourceFileDir) {
+    let root = this._rootsByFileDir.get(sourceFileDir);
+    if (!root) {
+      root = this._findModuleRoot(sourceFileDir);
+      if (!root) {
+        throw new Error(`${sourceFileDir} is not within any Node module.`);
+      }
+      this._rootsByFileDir.set(sourceFileDir, root); // remember for next files
+    }
+    return root;
+  }
+
+  /**
+   * @param sourceFileDir {string}
+   * @returns {string}
+   */
+  _findModuleRoot(sourceFileDir) {
+    while (sourceFileDir && !fs.existsSync(path.join(sourceFileDir, 'package.json'))) {
+      sourceFileDir = path.dirname(sourceFileDir);
+    }
+    return sourceFileDir.replaceAll('\\', '/');
+  }
+};

package/scripts/webpack-defaults.js

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2024 BSI Business Systems Integration AG
+ * Copyright (c) 2010, 2025 BSI Business Systems Integration AG
  *
  * This program and the accompanying materials are made
  * available under the terms of the Eclipse Public License 2.0
@@ -10,11 +10,14 @@
 const fs = require('fs');
 const path = require('path');
 const scoutBuildConstants = require('./constants');
+const DataObjectTransformer = require('./DataObjectTransformer');
+const ModuleNamespaceResolver = require('./ModuleNamespaceResolver');
 const CopyPlugin = require('copy-webpack-plugin');
 const {CycloneDxWebpackPlugin} = require('@cyclonedx/webpack-plugin');
 const MiniCssExtractPlugin = require('mini-css-extract-plugin');
 const AfterEmitWebpackPlugin = require('./AfterEmitWebpackPlugin');
 const {SourceMapDevToolPlugin, WatchIgnorePlugin, ProgressPlugin} = require('webpack');
+const ts = require('typescript');
 
 /**
  * @param {string} args.mode development or production
@@ -26,6 +29,7 @@ const {SourceMapDevToolPlugin, WatchIgnorePlugin, ProgressPlugin} = require('web
  * @param {string} args.cyclonedxVersion CycloneDX version to use. Default is '1.5'.
  * @param {[]} args.resDirArray an array containing directories which should be copied to dist/res
  * @param {object} args.tsOptions a config object to be passed to the ts-loader
+ * @param {object} args.forkTypeCheckOptions a config object to be passed to the ForkTsCheckerWebpackPlugin
  * @param {boolean|'fork'} args.typeCheck
  *    true: let the TypeScript compiler check the types.
  *    false: let the TypeScript compiler only transpile the TypeScript code without checking types, which makes it faster.
@@ -61,7 +65,10 @@ module.exports = (env, args) => {
       });
   }
 
-  const minimizerTarget = ['firefox69', 'chrome71', 'safari13'];
+  // browser min. requirements for full ES2022 feature set
+  // Exception: static initialization blocks (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/Static_initialization_blocks) which would require Safari 16
+  // But static initialization blocks can be transpiled by Babel to static fields which are supported in all these browsers. Therefore, in the code full ES2022 feature set can be used.
+  const minimizerTarget = ['firefox92', 'chrome93', 'safari15.4'];
   const babelOptions = {
     compact: false,
     cacheDirectory: true,
@@ -70,22 +77,31 @@ module.exports = (env, args) => {
       [require.resolve('@babel/preset-env'), {
         debug: false,
         targets: {
-          firefox: '69',
-          chrome: '71',
-          safari: '13'
+          firefox: '92',
+          chrome: '93',
+          safari: '15.4'
         }
       }]
     ]
   };
 
   const transpileOnly = typeCheck === 'fork' ? true : !typeCheck;
+  const namespaceResolver = new ModuleNamespaceResolver();
+  const getCustomTransformers = program => ({
+    before: [ctx => {
+      const doTransformer = new DataObjectTransformer(program, ctx, namespaceResolver);
+      return node => ts.visitNode(node, node => doTransformer.transform(node));
+    }]
+  });
+  getCustomTransformers.namespaceResolver = namespaceResolver; // for setDoTransformerOwnModuleNamespace below
   const tsOptions = {
     ...args.tsOptions,
     transpileOnly: transpileOnly,
     compilerOptions: {
       noEmit: false,
       ...args.tsOptions?.compilerOptions
-    }
+    },
+    getCustomTransformers
   };
 
   const config = {
@@ -177,7 +193,7 @@ module.exports = (env, args) => {
           }
         }]
       }, {
-        test: /\.tsx?$/,
+        test: /\.[c|m]?tsx?$/,
         exclude: /node_modules/,
         use: [{
           loader: require.resolve('babel-loader'),
@@ -187,13 +203,13 @@ module.exports = (env, args) => {
           options: tsOptions
         }]
       }, {
-        test: /\.jsx?$/,
+        test: /\.[c|m]?jsx?$/,
         use: [{
           loader: require.resolve('babel-loader'),
           options: babelOptions
         }]
       }, {
-        test: /\.jsx?$/,
+        test: /\.[c|m]?jsx?$/,
         enforce: 'pre',
         use: [{
           loader: require.resolve('source-map-loader')
@@ -245,13 +261,16 @@ module.exports = (env, args) => {
 
     let forkTsCheckerConfig = {
       typescript: {
-        memoryLimit: 4096
-      }
+        memoryLimit: 4096,
+        ...args.forkTypeCheckOptions?.typescript
+      },
+      ...args.forkTypeCheckOptions
     };
     if (!fs.existsSync('./tsconfig.json')) {
       // if the module has no tsconfig: use default from Scout.
       // Otherwise, each module would need to provide a tsconfig even if there is no typescript code in the module.
       forkTsCheckerConfig = {
+        ...forkTsCheckerConfig,
         typescript: {
           ...forkTsCheckerConfig.typescript,
           configFile: require.resolve('@eclipse-scout/tsconfig'),
@@ -335,6 +354,19 @@ function toExternals(src, dest) {
   }, dest);
 }
 
+/**
+ * Sets the Scout JS module namespace for the root module currently built.
+ * @param config The build config to modify.
+ * @param namespace The namespace of this module.
+ */
+function setDoTransformerOwnModuleNamespace(config, namespace) {
+  config.module.rules
+    .flatMap(r => r.use || [])
+    .find(l => l.loader?.indexOf('ts-loader') >= 0)
+    .options.getCustomTransformers.namespaceResolver
+    .ownModuleNamespace = namespace;
+}
+
 /**
  * Converts the given base config to a library config meaning that all dependencies declared in the package.json are externalized by default.
  *
@@ -624,4 +656,5 @@ function computeTypeCheck(typeCheck, devMode, watchMode) {
 module.exports.addThemes = addThemes;
 module.exports.libraryConfig = libraryConfig;
 module.exports.markExternals = markExternals;
+module.exports.setDoTransformerOwnModuleNamespace = setDoTransformerOwnModuleNamespace;
 module.exports.rewriteIndexImports = rewriteIndexImports;