@eclipse-scout/migrate 23.1.1

package/src/convertToLFPlugin.js

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2010, 2023 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
+ */
+
+/**
+ * @type import('ts-migrate-server').Plugin<unknown>
+ */
+import {crlfToLf} from './common.js';
+import {filesConvertedToCrLf} from './convertToCRLFPlugin.js';
+
+/**
+ * @type import('ts-migrate-server').Plugin<{}>
+ */
+const convertToLFPlugin = {
+  name: 'convert-to-lf',
+
+  run({text, fileName}) {
+    if (filesConvertedToCrLf.has(fileName)) {
+      // revert line ending style to lf
+      return crlfToLf(text);
+    }
+  }
+};
+
+export default convertToLFPlugin;

package/src/countMethodsPlugin.js

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2010, 2023 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
+ */
+import jscodeshift from 'jscodeshift';
+import {methodFilter} from './common.js';
+
+const j = jscodeshift.withParser('ts');
+let total = 0;
+/**
+ * @type import('ts-migrate-server').Plugin<unknown>
+ */
+const countMethods = {
+  name: 'count-methods-plugin',
+
+  async run({text, fileName}) {
+    const root = j(text);
+    let count = 0;
+    root.find(j.Declaration)
+      .filter(path => methodFilter(j, path))
+      .forEach(expression => {
+        count++;
+      });
+    total += count;
+    console.log(fileName + ': ' + count);
+    console.log('Total: ' + total);
+    return text;
+  }
+};
+
+export default countMethods;

package/src/declareMissingClassPropertiesPlugin.js

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2010, 2023 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
+ */
+
+/*
+ * Based on https://github.com/airbnb/ts-migrate/blob/master/packages/ts-migrate-plugins/src/plugins/declare-missing-class-properties.ts (MIT License)
+ * See readme.md for details.
+ */
+import jscodeshift from 'jscodeshift';
+import {validateAnyAliasOptions} from 'ts-migrate-plugins/build/src/utils/validateOptions.js';
+import {isDiagnosticWithLinePosition} from 'ts-migrate-plugins/build/src/utils/type-guards.js';
+import {defaultModuleMap, defaultParamTypeMap, defaultRecastOptions, findClassProperty, findIndex, findParentClassBody, findParentPath, getTypeFor, inConstructor, insertMissingImportsForTypes, removeEmptyLinesBetweenImports, transformCommentLinesToJsDoc} from './common.js';
+
+const j = jscodeshift.withParser('ts');
+let root;
+let referencedTypes;
+const propertyComparator = (a, b) => {
+  // Move $ and _ variables to the end
+  if (a.startsWith('_') && !b.startsWith('_')) {
+    return 1;
+  }
+  if (b.startsWith('_') && !a.startsWith('_')) {
+    return -1;
+  }
+  if (a.startsWith('$') && !b.startsWith('$')) {
+    return 1;
+  }
+  if (b.startsWith('$') && !a.startsWith('$')) {
+    return -1;
+  }
+  return 0;
+};
+
+/**
+ * @type import('ts-migrate-server').Plugin<{ anyAlias?: string, typeMap?: object, moduleMap?: object}>
+ */
+const declareMissingClassPropertiesPlugin = {
+  name: 'declare-missing-class-properties',
+
+  async run({text, fileName, getLanguageService, options, sourceFile}) {
+    const diagnostics = getLanguageService()
+      .getSemanticDiagnostics(fileName)
+      .filter(isDiagnosticWithLinePosition)
+      .filter(diagnostic => diagnostic.code === 2339 || diagnostic.code === 2551); // 2339: Property_0_does_not_exist_on_type_1, 2551: Property_0_does_not_exist_on_type_1_Did_you_mean_
+
+    root = j(text);
+
+    const toAdd = [];
+    const typeMap = {...defaultParamTypeMap, ...options.typeMap};
+    const moduleMap = {...defaultModuleMap, ...options.moduleMap};
+    referencedTypes = new Set();
+
+    // Diagnostics are errors reported by typescript -> the plugin only processes missing properties
+    diagnostics.forEach(diagnostic => {
+      root
+        .find(j.Identifier)
+        .filter(
+          path =>
+            (path.node).start === diagnostic.start &&
+            (path.node).end === diagnostic.start + diagnostic.length &&
+            path.parentPath.node.type === 'MemberExpression' &&
+            path.parentPath.node.object.type === 'ThisExpression' &&
+            path.parentPath.parentPath.node.type === 'AssignmentExpression' && path.parentPath.parentPath.node.operator === '=' &&
+            inConstructor(path)
+        )
+        .forEach(path => {
+          const classBody = findParentClassBody(path);
+          if (!classBody) {
+            return;
+          }
+          let item = toAdd.find(cur => cur.classBody === classBody);
+          if (!item) {
+            item = {classBody, propertyNames: new Map()};
+            toAdd.push(item);
+          }
+
+          let assignment = findParentPath(path, parentPath => parentPath.node.type === 'AssignmentExpression');
+          let typeDesc = getTypeFor(j, path.node.name, assignment.node.right, Object.values(typeMap));
+          if (typeDesc && typeDesc.module) {
+            referencedTypes.add(typeDesc);
+          }
+          let property = {
+            type: typeDesc.type
+          };
+          if (assignment.parentPath.node.comments) {
+            property.comments = assignment.parentPath.node.comments;
+            // Remove comment from property assignment
+            assignment.parentPath.node.comments = null;
+          }
+          item.propertyNames.set(path.node.name, property);
+        });
+    });
+
+    toAdd.forEach(({classBody, propertyNames: properties}) => {
+      const /** @type {string[]}*/ propertyNames = Array.from(properties.keys())
+        .filter(propertyName => {
+          const existingProperty = findClassProperty(classBody, propertyName);
+          return existingProperty == null;
+        })
+        .sort(propertyComparator);
+
+      // Insert before constructor
+      let index = findIndex(classBody.node.body, node => node.type === 'ClassMethod' && node.kind === 'constructor');
+      if (index < 0) {
+        index = 0;
+      }
+      classBody.node.body.splice(
+        index,
+        0,
+        ...propertyNames.map(propertyName => {
+          let propertyDesc = properties.get(propertyName);
+          let prop = j.classProperty(
+            j.identifier(propertyName),
+            null,
+            j.tsTypeAnnotation(propertyDesc.type)
+          );
+          let comments = transformCommentLinesToJsDoc(j, propertyDesc.comments);
+          if (comments) {
+            prop.comments = comments;
+          }
+          return prop;
+        })
+      );
+    });
+
+    insertMissingImportsForTypes(j, root, Array.from(referencedTypes), moduleMap, sourceFile.fileName);
+    return removeEmptyLinesBetweenImports(root.toSource(defaultRecastOptions));
+  },
+
+  validate: validateAnyAliasOptions
+};
+
+export default declareMissingClassPropertiesPlugin;

package/src/memberAccessModifierPlugin.js

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2010, 2023 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
+ */
+import jscodeshift from 'jscodeshift';
+import {defaultRecastOptions} from './common.js';
+
+const j = jscodeshift.withParser('ts');
+
+/**
+ * @type import('ts-migrate-server').Plugin<unknown>
+ */
+const memberAccessModifierPlugin = {
+  name: 'member-access-modifier-plugin',
+
+  async run({text}) {
+    const root = j(text);
+    // Declaration is base type for ClassMethod and ClassProperty according to https://github.com/benjamn/ast-types/tree/master/def
+    return root.find(j.Declaration)
+      .filter(path => path.node.type === j.ClassMethod.name || path.node.type === j.ClassProperty.name)
+      .forEach(expression => {
+        if (expression.node.accessibility) {
+          return;
+        }
+        let name = expression.node.key.name;
+        if (name && name.startsWith('_') && !containsInternalInJsDoc(expression.node)) {
+          expression.node.accessibility = 'protected';
+        }
+      }).toSource(defaultRecastOptions);
+  }
+};
+
+function containsInternalInJsDoc(node) {
+  let comments = node.comments;
+  if (!comments) {
+    return false;
+  }
+  return comments.some(comment => {
+    if (comment.type !== 'CommentBlock') {
+      return false;
+    }
+    return comment.value.includes('@internal');
+  });
+}
+
+export default memberAccessModifierPlugin;

package/src/menuTypesPlugin.js

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2010, 2023 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
+ */
+
+// noinspection SpellCheckingInspection
+import jscodeshift from 'jscodeshift';
+import {defaultMenuTypesMap, defaultModuleMap, defaultRecastOptions, insertMissingImportsForTypes, mapType} from './common.js';
+
+const j = jscodeshift.withParser('ts');
+
+/**
+ * @type import('ts-migrate-server').Plugin<{menuTypesMap?: object, moduleMap?: object}>
+ */
+const menuTypesPlugin = {
+  name: 'menu-types-plugin',
+
+  async run({text, fileName, options}) {
+    let root = j(text),
+      referencedTypes = new Set();
+    const menuTypesMap = {...defaultMenuTypesMap, ...options.menuTypesMap},
+      moduleMap = {...defaultModuleMap, ...options.moduleMap};
+
+    // noinspection JSCheckFunctionSignatures
+    root.find(j.ObjectProperty, {key: {name: 'menuTypes'}})
+      .forEach(/** NodePath<ObjectProperty, ObjectProperty> */path => {
+        let node = path.node;
+        if (!node.value || node.value.type !== 'ArrayExpression') {
+          return;
+        }
+        let elements = node.value.elements;
+        for (let i = 0; i < elements.length; i++) {
+          let element = elements[i];
+          if (!element || element.type !== 'StringLiteral') {
+            continue;
+          }
+          let menuType = getMenuTypeForStringMenuType(element.value, menuTypesMap, referencedTypes);
+          if (!menuType) {
+            continue;
+          }
+          elements.splice(i, 1, menuType);
+        }
+      });
+
+    insertMissingImportsForTypes(j, root, Array.from(referencedTypes), moduleMap, fileName);
+    return root.toSource(defaultRecastOptions);
+  }
+};
+
+function getMenuTypeForStringMenuType(menuTypeString, menuTypeMap, referencedTypes) {
+  let menuTypeInfo = menuTypeMap[menuTypeString];
+  if (!menuTypeInfo) {
+    return null;
+  }
+  let {objectType, menuTypes, menuType} = menuTypeInfo;
+  if (!objectType || !menuTypes || !menuType) {
+    return null;
+  }
+
+  // noinspection DuplicatedCode
+  let module = 'scout';
+  let name = objectType;
+  if (objectType.indexOf('.') > -1) {
+    [module, name] = objectType.split('.');
+  }
+  let type = mapType(j, module + '.' + name);
+  referencedTypes.add(type);
+
+  return j.memberExpression(j.memberExpression(j.identifier(name), j.identifier(menuTypes)), j.identifier(menuType));
+}
+
+export default menuTypesPlugin;

package/src/methodsPlugin.js

@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2010, 2023 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
+ */
+import jscodeshift from 'jscodeshift';
+import {defaultModuleMap, defaultParamTypeMap, defaultRecastOptions, defaultReturnTypeMap, findTypeByName, insertMissingImportsForTypes, mapType, methodFilter, removeEmptyLinesBetweenImports} from './common.js';
+
+const j = jscodeshift.withParser('ts');
+let referencedTypes;
+
+/**
+ * Processes class methods and exported functions of utilities.
+ *
+ * Adds parameter and return types based on naming rules defined in type maps (see {@link defaultParamTypeMap} and {@link defaultParamTypeMap}).
+ * Custom type rules can be specified with an option.
+ *
+ * Also adds required imports for the added types.
+ * The types in the type maps can be prefixed with a module name that will be mapped to a npm module by the provided moduleMap (see {@link defaultModuleMap}).
+ *
+ * Finally, the js doc comments are cleaned up, which means the type information is removed.
+ *
+ * @type import('ts-migrate-server').Plugin<{paramTypeMap?: object, returnTypeMap?: object, moduleMap?: object, defaultReturnType?: string, defaultParamType?: string}>
+ */
+const methodsPlugin = {
+  name: 'methods-plugin',
+
+  async run({text, options, sourceFile}) {
+    let root = j(text);
+    const paramTypeMap = {...defaultParamTypeMap, ...options.paramTypeMap};
+    const returnTypeMap = {...defaultReturnTypeMap, ...options.returnTypeMap};
+    const moduleMap = {...defaultModuleMap, ...options.moduleMap};
+    const defaultReturnType = options.defaultReturnType;
+    const defaultParamType = options.defaultParamType;
+    referencedTypes = new Set();
+
+    root.find(j.Declaration)
+      .filter(path => methodFilter(j, path))
+      .forEach(expression => {
+        let node = expression.node;
+        if (node.params) {
+          for (let param of node.params) {
+            processParamType(param, Object.values(paramTypeMap), defaultParamType);
+          }
+        }
+        processReturnType(node, Object.values(returnTypeMap), defaultReturnType);
+        removeJsDocTypes(node);
+      });
+
+    insertMissingImportsForTypes(j, root, Array.from(referencedTypes), moduleMap, sourceFile.fileName);
+    return removeEmptyLinesBetweenImports(root.toSource(defaultRecastOptions));
+  }
+};
+
+function processReturnType(func, typeMaps, defaultReturnType) {
+  let name = func.key ? func.key.name : func.id.name;
+  if (func.returnType) {
+    return;
+  }
+  let typeDesc = findTypeByName(j, typeMaps, name);
+  if (!typeDesc && defaultReturnType && func.kind !== 'constructor' && func.kind !== 'set') {
+    typeDesc = mapType(j, defaultReturnType);
+  }
+  if (typeDesc) {
+    func.returnType = j.tsTypeAnnotation(typeDesc.type);
+    if (typeDesc.module) {
+      referencedTypes.add(typeDesc);
+    }
+  }
+}
+
+function processParamType(param, typeMaps, defaultParamType) {
+  let name = param.name;
+  if (param.typeAnnotation) {
+    return;
+  }
+  let typeDesc = findTypeByName(j, typeMaps, name);
+  if (!typeDesc && defaultParamType) {
+    typeDesc = mapType(j, defaultParamType);
+  }
+  if (typeDesc) {
+    param.typeAnnotation = j.tsTypeAnnotation(typeDesc.type);
+    if (typeDesc.module) {
+      referencedTypes.add(typeDesc);
+    }
+  }
+}
+
+/**
+ * Removes all types form jsdoc if the types exist as TS types
+ */
+function removeJsDocTypes(func) {
+  let comments = func.comments;
+  if (!comments) {
+    return;
+  }
+  let replaceReturnType = !!func.returnType;
+  let replaceParams = [];
+  if (func.params) {
+    replaceParams = func.params.filter(param => !!param.typeAnnotation);
+  }
+  if (!replaceReturnType && replaceParams.length === 0) {
+    return;
+  }
+  func.comments = comments.map(comment => {
+    if (comment.type !== 'CommentBlock') {
+      return comment;
+    }
+    let str = comment.value;
+    str = str.replaceAll(/ +\*/g, ''); // remove * at start of lines, makes the upcoming processing easier
+    let beforeReplace = str;
+    if (replaceReturnType) {
+      str = str.replace(/(@return[s]?) ({.*})/, '@returns'); // remove type from @return
+      str = str.replace(/@returns[\s]*$/, ''); // remove empty return at the end
+    }
+    for (let param of replaceParams) {
+      str = str.replace(new RegExp(`@param {.*} \\[?${param.name}\\]?`), `@param ${param.name}`); // remove type from @param
+      str = str.replace(new RegExp(`@param \\[?${param.name}\\]? {.*}`), `@param ${param.name}`); // consider reverse typing as well (@param [var] {type} instead of @param {type} [var]
+      str = str.replace(new RegExp(`@param \\[${param.name}\\]`), `@param ${param.name}`); // remove brackets even without type
+      str = str.replace(new RegExp(`@param ${param.name}[\\s]*$`), ''); // remove empty param at end
+      str = str.replace(new RegExp(`@param ${param.name}[\\s]*@param`), '@param'); // remove empty param before param
+      str = str.replace(new RegExp(`@param ${param.name}[\\s]*@return`), '@return'); // remove empty param before return
+    }
+    if (beforeReplace === str) {
+      // Do nothing if nothing was replaced
+      return comment;
+    }
+    str = str.replace(/\r\n +$/, '\r\n'); // remove whitespaces at the end (keep new line)
+    str = str.replaceAll(/\r\n/g, '\r\n *'); // add * again
+    str = str.replace(/\r\n \*$/, '\r\n'); // Remove last * that was added by the line before. It will be added automatically by the block comment.
+    if (str.trim() === '*') {
+      // Remove empty comments
+      return null;
+    }
+    return j.commentBlock(str);
+  }).filter(comment => comment !== null);
+}
+
+export default methodsPlugin;

package/src/printEventMapsPlugin.js

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2010, 2023 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
+ */
+import jscodeshift from 'jscodeshift';
+import {findClassProperty, findParentClassBody, getNameForType, isOneOf} from './common.js';
+
+const j = jscodeshift.withParser('ts');
+
+/**
+ * @type import('ts-migrate-server').Plugin<{}>
+ */
+const printEventMapsPlugin = {
+  name: 'print-event-maps-plugin',
+
+  async run({text, fileName, options}) {
+    let root = j(text);
+
+    let eventLines = new Set();
+    let propEvents = new Map();
+    let className = fileName.substring(fileName.lastIndexOf('/') + 1, fileName.lastIndexOf('.'));
+
+    root.find(j.CallExpression)
+      .filter(path =>
+        path.value.callee.type === 'MemberExpression'
+        && path.value.callee.object.type === 'ThisExpression'
+        && isOneOf(path.value.callee.property.name, 'setProperty', '_setProperty', 'trigger')
+      )
+      .forEach(expression => {
+        let funcName = expression.value.callee.property.name;
+        let eventName = expression.value.arguments[0]?.value;
+        if (isOneOf(funcName, 'setProperty', '_setProperty')) {
+          let type = '?';
+          let property = findClassProperty(findParentClassBody(expression), eventName);
+          if (property) {
+            let typeAnnotation = property.typeAnnotation;
+            type = typeAnnotation ? getNameForType(j, typeAnnotation?.typeAnnotation) || '?' : '?';
+          }
+          let value = propEvents.get(eventName);
+          if (value && !value.includes('<?>')) {
+            // Don't replace existing value if it already has a type
+            return;
+          }
+          propEvents.set(eventName, `'propertyChange:${eventName}': PropertyChangeEvent<${type}>;`);
+        } else {
+          let eventObj = expression.value.arguments[1];
+          let event = '?';
+          if (!eventObj) {
+            event = `Event<${className}>`;
+          }
+          if (!eventName) {
+            return;
+          }
+          eventLines.add(`'${eventName}': ${event};`);
+        }
+      });
+
+    if (eventLines.size > 0 || propEvents.size > 0) {
+      console.log(`${className}EventMap`);
+      if (eventLines.size > 0) {
+        console.log(Array.from(eventLines).sort().join('\n'));
+      }
+      if (propEvents.size > 0) {
+        console.log(Array.from(propEvents.values()).sort().join('\n'));
+      }
+      console.log('\n');
+    }
+
+    return text;
+  }
+};
+
+export default printEventMapsPlugin;

package/src/typedObjectTypePlugin.js

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2010, 2023 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
+ */
+import jscodeshift from 'jscodeshift';
+import {defaultModuleMap, defaultRecastOptions, insertMissingImportsForTypes, isOneOf, mapType, removeEmptyLinesBetweenImports} from './common.js';
+
+const j = jscodeshift.withParser('ts');
+let referencedTypes;
+
+/**
+ * @type import('ts-migrate-server').Plugin<{moduleMap?: object}>
+ */
+const typedObjectTypePlugin = {
+  name: 'typed-object-type-plugin',
+
+  async run({text, options, sourceFile}) {
+    let root = j(text);
+    const moduleMap = {...defaultModuleMap, ...options.moduleMap};
+    referencedTypes = new Set();
+
+    root.find(j.ObjectProperty)
+      .filter(path =>
+        isOneOf(path.value.key.name, 'objectType', 'logicalGrid', 'lookupCall') &&
+        path.value.value.type === j.StringLiteral.name)
+      .forEach(path => {
+        let objectType = path.value.value.value;
+        path.node.value = getTypeForStringObjectType(objectType);
+      });
+
+    root.find(j.CallExpression)
+      .filter(path =>
+        path.value.callee.type === j.MemberExpression.name &&
+        path.value.callee.object.name === 'scout' &&
+        path.value.callee.property.name === 'create' &&
+        path.value.arguments[0].type === j.StringLiteral.name)
+      .forEach(path => {
+        let objectType = path.value.arguments[0].value;
+        path.node.arguments[0] = getTypeForStringObjectType(objectType);
+      });
+
+    insertMissingImportsForTypes(j, root, Array.from(referencedTypes), moduleMap, sourceFile.fileName);
+    return removeEmptyLinesBetweenImports(root.toSource(defaultRecastOptions));
+  }
+};
+
+function getTypeForStringObjectType(objectType) {
+  // noinspection DuplicatedCode
+  let module = 'scout';
+  let name = objectType;
+  if (objectType.indexOf('.') > -1) {
+    [module, name] = objectType.split('.');
+  }
+  let type = mapType(j, module + '.' + name);
+  referencedTypes.add(type);
+  return j.identifier(name);
+}
+
+export default typedObjectTypePlugin;