feat(ts-interface-generator): support ts path mappings with configDir template variable (#492)

stabpd · web-flow · commit 4d3aafeb0451 · 2025-03-12T19:47:56.000+01:00
fix #484
diff --git a/packages/ts-interface-generator/src/addSourceExports.ts b/packages/ts-interface-generator/src/addSourceExports.ts
@@ -36,7 +36,7 @@ function addSourceExports(
   const filePath = path.normalize(fileName); // e.g. 'c:\SAPDevelop\git\ui5-typescript-control-library\src-ts\com\myorg\myUI5Library\Example.ts
   let globalName: string, moduleFileName: string;
   for (let i = 0; i < allPathMappings.length; i++) {
-    const fullTargetPath = path.join(basePath, allPathMappings[i].target);
+    const fullTargetPath = path.resolve(basePath, allPathMappings[i].target);
     if (filePath.indexOf(fullTargetPath) === 0) {
       const restPath = filePath.replace(fullTargetPath, "");
       moduleFileName = path
diff --git a/packages/ts-interface-generator/src/generateTSInterfacesAPI.ts b/packages/ts-interface-generator/src/generateTSInterfacesAPI.ts
@@ -60,23 +60,14 @@ export function main(args: Args) {
 }
 
 /**
- * Whenever the code changes, this is called, in oder to re-generate the interfaces
- *
+ * Extracts known local exports and relevant source files from program.
  *
- * TODO: can we use the knowledge about the changed files to limit the scope here?
- *       A Problem is that also a change in a different file could influence the generation of an unchanged file. E.g. when an update of the
- *       UI5 type definitions changes the base class of sap.m.Button to something where API methods are not generated, then
- *       the next generation run would no longer create a *.gen.d.ts file for Controls deriving from Button (ok, extreme example...)
  * @param program
  * @param typeChecker
- * @param changedFiles
- * @param allKnownGlobals
  */
-function onTSProgramUpdate(
+export function getProgramInfo(
   program: ts.Program,
   typeChecker: ts.TypeChecker,
-  changedFiles: string[], // is an empty array in non-watch case; is at least one file in watch case - but overall not reliable!
-  allKnownGlobals: GlobalToModuleMapping,
 ) {
   // this block collects all path mappings from the compiler configuration, so we can find out the logical name for a concrete file path
   const paths = program.getCompilerOptions().paths;
@@ -134,6 +125,33 @@ function onTSProgramUpdate(
       ); // extract all local exports
     });
 
+  return { allRelevantSourceFiles, allKnownLocalExports };
+}
+
+/**
+ * Whenever the code changes, this is called, in oder to re-generate the interfaces
+ *
+ *
+ * TODO: can we use the knowledge about the changed files to limit the scope here?
+ *       A Problem is that also a change in a different file could influence the generation of an unchanged file. E.g. when an update of the
+ *       UI5 type definitions changes the base class of sap.m.Button to something where API methods are not generated, then
+ *       the next generation run would no longer create a *.gen.d.ts file for Controls deriving from Button (ok, extreme example...)
+ * @param program
+ * @param typeChecker
+ * @param changedFiles
+ * @param allKnownGlobals
+ */
+function onTSProgramUpdate(
+  program: ts.Program,
+  typeChecker: ts.TypeChecker,
+  changedFiles: string[], // is an empty array in non-watch case; is at least one file in watch case - but overall not reliable!
+  allKnownGlobals: GlobalToModuleMapping,
+) {
+  const { allRelevantSourceFiles, allKnownLocalExports } = getProgramInfo(
+    program,
+    typeChecker,
+  );
+
   // now actually generate the interface files for all source files
   allRelevantSourceFiles.forEach((sourceFile) => {
     generateInterfaces(
diff --git a/packages/ts-interface-generator/src/test/testcases/testcaseRunner.test.ts b/packages/ts-interface-generator/src/test/testcases/testcaseRunner.test.ts
@@ -4,6 +4,7 @@ import ts from "typescript";
 import log from "loglevel";
 import { generateInterfaces } from "../../interfaceGenerationHelper";
 import { getAllKnownGlobals, GlobalToModuleMapping } from "../../typeScriptEnvironment";
+import { getProgramInfo } from "../../generateTSInterfacesAPI";
 
 const testCasesDir = path.resolve(__dirname);
 
@@ -34,6 +35,18 @@ describe("Single Testcases", () => {
       return;
     }
 
+    function parseConfig(tsConfigPath: string) {
+      let config: ts.CompilerOptions;
+      if (fs.existsSync(tsConfigPath)) {
+        const json: unknown = ts.parseConfigFileTextToJson(tsConfigPath, fs.readFileSync(tsConfigPath).toString()).config || {};
+        config = ts.parseJsonConfigFileContent(json, ts.sys, path.dirname(tsConfigPath)).options;
+      } else {
+        config = {...standardTsConfig};
+      }
+      config.baseUrl = testCaseDir;
+      return config;
+    }
+
     test(`Interface generation for ${testCase}`, async () => {
       // setup TypeScript program
       const tsConfigPath = path.join(testCaseDir, "tsconfig.json");
@@ -42,15 +55,13 @@ describe("Single Testcases", () => {
         .filter((file) => file.endsWith(".ts") && !file.endsWith(".d.ts"))
         .map((file) => path.join(testCaseDir, file));
 
-      const tsConfig = fs.existsSync(tsConfigPath)
-        ? { configFilePath: tsConfigPath }
-        : standardTsConfig;
-      const program = ts.createProgram(tsFiles, tsConfig);
+      const program = ts.createProgram(tsFiles, parseConfig(tsConfigPath));
       const typeChecker = program.getTypeChecker();
+      const programInfo = getProgramInfo(program, typeChecker);
       const allKnownGlobals: GlobalToModuleMapping = getAllKnownGlobals(typeChecker);
 
       const sourceFiles = program.getSourceFiles().filter((sourceFile) => {
-        return !sourceFile.isDeclarationFile;
+        return !sourceFile.isDeclarationFile && path.basename(sourceFile.fileName) !== "library.ts";
       });
 
       const runGenerateInterfaces = async (
@@ -68,7 +79,7 @@ describe("Single Testcases", () => {
           generateInterfaces(
             sourceFile,
             typeChecker,
-            allKnownGlobals,
+            Object.assign({}, programInfo.allKnownLocalExports, allKnownGlobals),
             resultProcessor,
           );
         });
diff --git a/packages/ts-interface-generator/src/test/testcases/tsconfig-path-relative/MyControl.gen.d.ts b/packages/ts-interface-generator/src/test/testcases/tsconfig-path-relative/MyControl.gen.d.ts
@@ -0,0 +1,81 @@
+import { MyJSEnum } from "my/library";
+import { MyTSEnum } from "my/library";
+import MyDependency from "my/MyDependency";
+import { PropertyBindingInfo } from "sap/ui/base/ManagedObject";
+import { $ControlSettings } from "sap/ui/core/Control";
+
+declare module "./MyControl" {
+
+    /**
+     * Interface defining the settings object used in constructor calls
+     */
+    interface $MyControlSettings extends $ControlSettings {
+        myJSEnumVal?: MyJSEnum | PropertyBindingInfo | `{${string}}`;
+        myTSEnumVal?: MyTSEnum | PropertyBindingInfo | `{${string}}`;
+        myDependency?: MyDependency | PropertyBindingInfo | `{${string}}`;
+    }
+
+    export default interface MyControl {
+
+        // property: myJSEnumVal
+
+        /**
+         * Gets current value of property "myJSEnumVal".
+         *
+         * Default value is: "MyJSEnum.Foo,"
+         * @returns Value of property "myJSEnumVal"
+         */
+        getMyJSEnumVal(): MyJSEnum;
+
+        /**
+         * Sets a new value for property "myJSEnumVal".
+         *
+         * When called with a value of "null" or "undefined", the default value of the property will be restored.
+         *
+         * Default value is: "MyJSEnum.Foo,"
+         * @param [myJSEnumVal="MyJSEnum.Foo,"] New value for property "myJSEnumVal"
+         * @returns Reference to "this" in order to allow method chaining
+         */
+        setMyJSEnumVal(myJSEnumVal: MyJSEnum): this;
+
+        // property: myTSEnumVal
+
+        /**
+         * Gets current value of property "myTSEnumVal".
+         *
+         * Default value is: "MyTSEnum.Foo,"
+         * @returns Value of property "myTSEnumVal"
+         */
+        getMyTSEnumVal(): MyTSEnum;
+
+        /**
+         * Sets a new value for property "myTSEnumVal".
+         *
+         * When called with a value of "null" or "undefined", the default value of the property will be restored.
+         *
+         * Default value is: "MyTSEnum.Foo,"
+         * @param [myTSEnumVal="MyTSEnum.Foo,"] New value for property "myTSEnumVal"
+         * @returns Reference to "this" in order to allow method chaining
+         */
+        setMyTSEnumVal(myTSEnumVal: MyTSEnum): this;
+
+        // property: myDependency
+
+        /**
+         * Gets current value of property "myDependency".
+         *
+         * @returns Value of property "myDependency"
+         */
+        getMyDependency(): MyDependency;
+
+        /**
+         * Sets a new value for property "myDependency".
+         *
+         * When called with a value of "null" or "undefined", the default value of the property will be restored.
+         *
+         * @param myDependency New value for property "myDependency"
+         * @returns Reference to "this" in order to allow method chaining
+         */
+        setMyDependency(myDependency: MyDependency): this;
+    }
+}
diff --git a/packages/ts-interface-generator/src/test/testcases/tsconfig-path-relative/MyControl.ts b/packages/ts-interface-generator/src/test/testcases/tsconfig-path-relative/MyControl.ts
@@ -0,0 +1,24 @@
+import Control from "sap/ui/core/Control";
+import type { MetadataOptions } from "sap/ui/core/Element";
+import { MyJSEnum, MyTSEnum } from "./library";
+
+export default class MyControl extends Control {
+    static readonly metadata: MetadataOptions = {
+        properties: {
+            myJSEnumVal: {
+                type: "my.MyJSEnum",
+                defaultValue: MyJSEnum.Foo,
+            },
+            myTSEnumVal: {
+                type: "my.MyTSEnum",
+                defaultValue: MyTSEnum.Foo,
+            },
+            myDependency: {
+                type: "my.MyDependency",
+            },
+        },
+    };
+    constructor(idOrSettings?: string | $MyControlSettings);
+    constructor(id?: string, settings?: $MyControlSettings);
+    constructor(id?: string, settings?: $MyControlSettings) { super(id, settings); }
+}
diff --git a/packages/ts-interface-generator/src/test/testcases/tsconfig-path-relative/MyDependency.gen.d.ts b/packages/ts-interface-generator/src/test/testcases/tsconfig-path-relative/MyDependency.gen.d.ts
@@ -0,0 +1,36 @@
+import { PropertyBindingInfo } from "sap/ui/base/ManagedObject";
+import { $ControlSettings } from "sap/ui/core/Control";
+
+declare module "./MyDependency" {
+
+    /**
+     * Interface defining the settings object used in constructor calls
+     */
+    interface $MyDependencySettings extends $ControlSettings {
+        foo?: string | PropertyBindingInfo;
+    }
+
+    export default interface MyDependency {
+
+        // property: foo
+
+        /**
+         * Gets current value of property "foo".
+         *
+         * Default value is: "bar"
+         * @returns Value of property "foo"
+         */
+        getFoo(): string;
+
+        /**
+         * Sets a new value for property "foo".
+         *
+         * When called with a value of "null" or "undefined", the default value of the property will be restored.
+         *
+         * Default value is: "bar"
+         * @param [foo="bar"] New value for property "foo"
+         * @returns Reference to "this" in order to allow method chaining
+         */
+        setFoo(foo: string): this;
+    }
+}
diff --git a/packages/ts-interface-generator/src/test/testcases/tsconfig-path-relative/MyDependency.ts b/packages/ts-interface-generator/src/test/testcases/tsconfig-path-relative/MyDependency.ts
@@ -0,0 +1,17 @@
+import Control from "sap/ui/core/Control";
+import type { MetadataOptions } from "sap/ui/core/Element";
+
+export default class MyDependency extends Control {
+    static readonly metadata: MetadataOptions = {
+        properties: {
+            foo: {
+                type: "string",
+                defaultValue: "bar",
+            },
+        },
+    };
+
+    constructor(idOrSettings?: string | $MyDependencySettings);
+    constructor(id?: string, settings?: $MyDependencySettings);
+    constructor(id?: string, settings?: $MyDependencySettings) { super(id, settings); }
+}
diff --git a/packages/ts-interface-generator/src/test/testcases/tsconfig-path-relative/library.ts b/packages/ts-interface-generator/src/test/testcases/tsconfig-path-relative/library.ts
@@ -0,0 +1,29 @@
+import DataType from "sap/ui/base/DataType";
+import Lib from "sap/ui/core/Lib";
+
+const thisLib: object&{MyJSEnum?: object; MyTSEnum?: object} = Lib.init({
+    name: "my",
+    version: "${version}",
+    dependencies: ["sap.ui.core"],
+    types: [],
+    interfaces: [],
+    controls: [],
+    elements: [],
+    noLibraryCSS: false,
+});
+
+export const MyJSEnum = {
+    Foo: "foo",
+    Bar: "bar",
+} as const;
+thisLib.MyJSEnum = MyJSEnum;
+DataType.registerEnum("mylib.MyJSEnum", thisLib.MyJSEnum);
+
+export enum MyTSEnum {
+    Foo = "foo",
+    Bar = "bar",
+}
+thisLib.MyTSEnum = MyTSEnum;
+DataType.registerEnum("mylib.MyTSEnum", thisLib.MyTSEnum);
+
+export default thisLib;
diff --git a/packages/ts-interface-generator/src/test/testcases/tsconfig-path-relative/tsconfig.json b/packages/ts-interface-generator/src/test/testcases/tsconfig-path-relative/tsconfig.json
@@ -0,0 +1,15 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "Node16",
+        "strict": true,
+        "moduleResolution": "Node16",
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "noEmit": true,
+        "paths": {
+            "my/*": ["${configDir}/*"]
+        }
+    }
+}
