@sap-ux/ui5-test-writer 1.0.14 → 1.1.1

package/README.md

@@ -2,7 +2,7 @@
 
 # [`@sap-ux/ui5-test-writer`](https://github.com/SAP/open-ux-tools/tree/main/packages/ui5-test-writer)
 
-OPA files writer for use within Yeoman generator and other prompting libraries. 
+OPA files writer for use within Yeoman generator and other prompting libraries.
 
 
 ## Installation
@@ -17,7 +17,7 @@ Pnpm
 
 ## Usage
 
-2 public methods are available: one to generate all OPA test files for a Fiori elements for OData V4 application, another one to generate an additional page object file for a Fiori elements for OData V4 application.
+The `generateOPAFiles` function creates an OPA5 test suite for a Fiori elements for OData V4 application.
 
 ### Generate all OPA test files for a Fiori elements for OData V4 application
 
@@ -56,25 +56,25 @@ await exampleWriter();
 
 ```
 
-### Generate an additional page object file
+### TypeScript output
+
+Pass `enableTypeScript: true` in the options to generate the OPA test suite as TypeScript instead of JavaScript. The generated files use ES module syntax (`import` / `export default`) instead of AMD `sap.ui.define`, and include typed `Given` / `When` / `Then` parameters in journey functions.
 
-Calling the `generatePageObjectFile` function
 ```javascript
-import { generatePageObjectFile } from '@sap-ux/ui5-test-writer'
+import { generateOPAFiles } from '@sap-ux/ui5-test-writer'
 
-const exampleWriter = async () => {
-    const myProjectPath = 'path/to/my/project'; // Path to the root of the Fiori app
-    const targetKey = 'MyNewPage';  // Key of the target in the app descriptor (in sap.ui5/routing/targets)
-    const fs = await generatePageObjectFile(myProjectPath, { targetKey });
-    return new Promise((resolve) => {
-        fs.commit(resolve); // When using with Yeoman it handle the fs commit.
-    });
-}
+const fs = await generateOPAFiles(myProjectPath, { enableTypeScript: true });
+```
 
-// Calling the function
-await exampleWriter();
+What changes in the generated output:
 
-```
+- Page objects, journeys, and `JourneyRunner` are emitted as `.ts` files.
+- A `webapp/test/integration/types/OpaJourneyTypes.d.ts` file is generated with `Given` / `When` / `Then` definitions tailored to the app's pages.
+- The QUnit bootstrap (`opaTests.qunit.js`) and the HTML harness stay as `.js` / `.html` (they are loaded directly by the browser).
+
+When run in standalone mode against an existing project, `enableTypeScript` is auto-detected from the presence of a `tsconfig.json`. An explicit value passed in the options always takes precedence.
+
+Scope: TypeScript output is currently supported for List Report and Object Page templates.
 
 ## Keywords
 SAP Fiori Elements

package/dist/fiori-elements-opa-writer.d.ts

@@ -1,28 +1,20 @@
 import type { Editor } from 'mem-fs-editor';
 import type { Manifest } from '@sap-ux/project-access';
+import type { OPAGenerationOptions } from './types.js';
 import type { Logger } from '@sap-ux/logger';
 /**
  * Generate OPA test files for a Fiori elements for OData V4 application.
  * Note: this can potentially overwrite existing files in the webapp/test folder.
  *
  * @param basePath - the absolute target path where the application will be generated
- * @param opaConfig - parameters for the generation
- * @param opaConfig.scriptName - the name of the OPA journey file. If not specified, 'FirstJourney' will be used
- * @param opaConfig.htmlTarget - the name of the html that will be used in OPA journey file. If not specified, 'index.html' will be used
- * @param opaConfig.appID - the appID. If not specified, will be read from the manifest in sap.app/id
- * @param opaConfig.useVirtualPreviewEndpoints - when true, OPA harness files are served virtually; skip writing them to disk
+ * @param options - OPA generation options
  * @param metadata - optional metadata for the OPA test generation
  * @param fs - an optional reference to a mem-fs editor
  * @param log - optional logger instance
  * @param standalone - opa test generation run standalone, not during app generation
  * @returns Reference to a mem-fs-editor
  */
-export declare function generateOPAFiles(basePath: string, opaConfig: {
-    scriptName?: string;
-    appID?: string;
-    htmlTarget?: string;
-    useVirtualPreviewEndpoints?: boolean;
-}, metadata?: string, fs?: Editor, log?: Logger, standalone?: boolean): Promise<Editor>;
+export declare function generateOPAFiles(basePath: string, options: OPAGenerationOptions, metadata?: string, fs?: Editor, log?: Logger, standalone?: boolean): Promise<Editor>;
 /**
  * Reads the manifest for an app.
  *

package/dist/fiori-elements-opa-writer.js

@@ -3,7 +3,7 @@ import { fileURLToPath } from 'node:url';
 import { existsSync } from 'node:fs';
 import { create as createStorage } from 'mem-fs';
 import { create } from 'mem-fs-editor';
-import { SupportedPageTypes, ValidationError } from './types.js';
+import { SupportedPageTypes, ValidationError, DotFileExtension } from './types.js';
 import { t } from './i18n.js';
 import { FileName, DirName, getWebappPath, updatePackageScript } from '@sap-ux/project-access';
 import { getAppFeatures } from './utils/modelUtils.js';
@@ -16,22 +16,22 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
  * Note: this can potentially overwrite existing files in the webapp/test folder.
  *
  * @param basePath - the absolute target path where the application will be generated
- * @param opaConfig - parameters for the generation
- * @param opaConfig.scriptName - the name of the OPA journey file. If not specified, 'FirstJourney' will be used
- * @param opaConfig.htmlTarget - the name of the html that will be used in OPA journey file. If not specified, 'index.html' will be used
- * @param opaConfig.appID - the appID. If not specified, will be read from the manifest in sap.app/id
- * @param opaConfig.useVirtualPreviewEndpoints - when true, OPA harness files are served virtually; skip writing them to disk
+ * @param options - OPA generation options
  * @param metadata - optional metadata for the OPA test generation
  * @param fs - an optional reference to a mem-fs editor
  * @param log - optional logger instance
  * @param standalone - opa test generation run standalone, not during app generation
  * @returns Reference to a mem-fs-editor
  */
-export async function generateOPAFiles(basePath, opaConfig, metadata, fs, log, standalone = false) {
+export async function generateOPAFiles(basePath, options, metadata, fs, log, standalone = false) {
     const editor = fs ?? create(createStorage());
     const manifest = readManifest(editor, basePath);
     const { applicationType, hideFilterBar } = getAppTypeAndHideFilterBarFromManifest(manifest);
-    const config = createConfig(manifest, opaConfig, hideFilterBar);
+    const config = createConfig(manifest, options, hideFilterBar);
+    // In standalone mode, auto-detect TS vs JS from the project (presence of `tsconfig.json`)
+    // when the caller has not made an explicit choice. This enforces "TS app → TS tests, JS app → JS tests".
+    const enableTypeScript = options.enableTypeScript ?? (standalone && existsSync(join(basePath, FileName.Tsconfig)));
+    const dotFileExtension = enableTypeScript ? DotFileExtension.TS : DotFileExtension.JS;
     const rootCommonTemplateDirPath = join(__dirname, '../templates/common');
     const rootV4TemplateDirPath = join(__dirname, `../templates/${applicationType}`); // Only v4 is supported for the time being
     const testOutDirPath = join(await getWebappPath(basePath), 'test');
@@ -46,28 +46,43 @@ export async function generateOPAFiles(basePath, opaConfig, metadata, fs, log, s
         navigatedOP: LROP.pageOP?.targetKey,
         hideFilterBar: config.hideFilterBar
     };
-    const writeContext = { config, rootV4TemplateDirPath, testOutDirPath, editor, journeyParams };
+    const writeContext = {
+        config,
+        rootV4TemplateDirPath,
+        testOutDirPath,
+        editor,
+        journeyParams,
+        dotFileExtension
+    };
+    // The active context is the one used to actually emit files. In standalone mode without an
+    // existing JourneyRunner it is replaced with the resolved standalone context (which may
+    // override fields like `htmlTarget`); otherwise it stays as the original `writeContext`.
+    let activeContext = writeContext;
     if (standalone) {
-        const hasJourneyRunner = existsSync(join(testOutDirPath, 'integration', 'pages', 'JourneyRunner.js'));
+        const hasJourneyRunner = existsSync(join(testOutDirPath, 'integration', 'pages', `JourneyRunner${dotFileExtension}`));
         const virtualOPA5Configured = await hasVirtualOPA5(basePath);
         if (hasJourneyRunner) {
             writeJourneyFiles(appFeatures, writeContext, true, true, virtualOPA5Configured);
         }
         else {
-            const standaloneWriteContext = await resolveStandaloneWriteContext(basePath, testOutDirPath, writeContext, editor);
+            activeContext = await resolveStandaloneWriteContext(basePath, testOutDirPath, writeContext, editor);
             if (!virtualOPA5Configured) {
-                writeCommonAndPageFiles(standaloneWriteContext, rootCommonTemplateDirPath);
+                writeCommonAndPageFiles(activeContext, rootCommonTemplateDirPath);
             }
-            writeJourneyFiles(appFeatures, standaloneWriteContext, true, hasJourneyRunner, virtualOPA5Configured);
+            writeJourneyFiles(appFeatures, activeContext, true, hasJourneyRunner, virtualOPA5Configured);
         }
     }
     else {
-        writeCommonAndPageFiles(writeContext, rootCommonTemplateDirPath, opaConfig.useVirtualPreviewEndpoints ?? false);
-        writeJourneyFiles(appFeatures, writeContext, false, false, opaConfig.useVirtualPreviewEndpoints ?? false);
-        if (opaConfig.useVirtualPreviewEndpoints) {
+        const useVirtualPreviewEndpoints = options.useVirtualPreviewEndpoints ?? false;
+        writeCommonAndPageFiles(writeContext, rootCommonTemplateDirPath, useVirtualPreviewEndpoints);
+        writeJourneyFiles(appFeatures, writeContext, false, false, useVirtualPreviewEndpoints);
+        if (useVirtualPreviewEndpoints) {
             await addVirtualTestConfig(basePath, [{ framework: 'OPA5', path: '/test/integration/opaTests.qunit.html' }, { framework: 'Testsuite' }], editor);
         }
     }
+    if (enableTypeScript) {
+        writeOpaJourneyTypes(activeContext);
+    }
     return editor;
 }
 /**
@@ -217,22 +232,19 @@ function createPageConfig(manifest, targetKey, forcedAppID) {
  * Create the configuration object from the app descriptor.
  *
  * @param manifest - the app descriptor of the target app
- * @param opaConfig - parameters for the generation
- * @param opaConfig.scriptName - the name of the OPA journey file. If not specified, 'FirstJourney' will be used
- * @param opaConfig.htmlTarget - the name of the html file that will be used in the OPA journey file. If not specified, 'index.html' will be used
- * @param opaConfig.appID - the appID. If not specified, will be read from the manifest in sap.app/id
+ * @param options - OPA generation options
  * @param hideFilterBar - whether the filter bar should be hidden in the generated tests
  * @returns OPA test configuration object
  */
-function createConfig(manifest, opaConfig, hideFilterBar) {
+function createConfig(manifest, options, hideFilterBar) {
     // General application info
-    const { appID, appPath } = getAppFromManifest(manifest, opaConfig.appID);
+    const { appID, appPath } = getAppFromManifest(manifest, options.appID);
     const config = {
         appID,
         appPath,
         pages: [],
-        opaJourneyFileName: opaConfig.scriptName ?? 'FirstJourney',
-        htmlTarget: opaConfig.htmlTarget ?? 'index.html',
+        opaJourneyFileName: options.scriptName ?? 'FirstJourney',
+        htmlTarget: options.htmlTarget ?? 'index.html',
         hideFilterBar
     };
     // Identify startup targets from the routes
@@ -248,7 +260,7 @@ function createConfig(manifest, opaConfig, hideFilterBar) {
     // Create page configurations in supported cases
     const appTargets = manifest['sap.ui5']?.routing?.targets;
     for (const targetKey in appTargets) {
-        const pageConfig = createPageConfig(manifest, targetKey, opaConfig.appID);
+        const pageConfig = createPageConfig(manifest, targetKey, options.appID);
         if (pageConfig) {
             pageConfig.isStartup = startupTargets.includes(targetKey);
             config.pages.push(pageConfig);
@@ -311,7 +323,7 @@ function findLROP(pages, manifest) {
  * @param useVirtualPreviewEndpoints - when true, testsuite harness files are served virtually; skip writing them to disk
  */
 function writeCommonAndPageFiles(writeContext, rootCommonTemplateDirPath, useVirtualPreviewEndpoints = false) {
-    const { config, rootV4TemplateDirPath, testOutDirPath, editor, journeyParams } = writeContext;
+    const { config, rootV4TemplateDirPath, testOutDirPath, editor, journeyParams, dotFileExtension } = writeContext;
     // Common test files (testsuite served virtually when useVirtualPreviewEndpoints is enabled)
     if (!useVirtualPreviewEndpoints) {
         editor.copyTpl(join(rootCommonTemplateDirPath), testOutDirPath, 
@@ -321,36 +333,59 @@ function writeCommonAndPageFiles(writeContext, rootCommonTemplateDirPath, useVir
         });
     }
     config.pages.forEach((page) => {
-        writePageObject(page, rootV4TemplateDirPath, testOutDirPath, editor);
+        writePageObject(page, rootV4TemplateDirPath, testOutDirPath, editor, dotFileExtension);
     });
-    editor.copyTpl(join(rootV4TemplateDirPath, 'integration', 'FirstJourney.js'), join(testOutDirPath, 'integration', `${config.opaJourneyFileName}.js`), journeyParams, undefined, {
+    editor.copyTpl(join(rootV4TemplateDirPath, 'integration', `FirstJourney${dotFileExtension}`), join(testOutDirPath, 'integration', `${config.opaJourneyFileName}${dotFileExtension}`), { ...journeyParams, appPath: config.appPath }, undefined, {
         globOptions: { dot: true }
     });
     // Journey Runner
-    editor.copyTpl(join(rootV4TemplateDirPath, 'integration', 'pages', 'JourneyRunner.js'), join(testOutDirPath, 'integration', 'pages', 'JourneyRunner.js'), config, undefined, {
+    editor.copyTpl(join(rootV4TemplateDirPath, 'integration', 'pages', `JourneyRunner${dotFileExtension}`), join(testOutDirPath, 'integration', 'pages', `JourneyRunner${dotFileExtension}`), config, undefined, {
+        globOptions: { dot: true }
+    });
+}
+/**
+ * Writes the OpaJourneyTypes.d.ts type definition file used by generated TypeScript OPA tests.
+ *
+ * @param writeContext - shared write context (config, paths, editor, journey params)
+ */
+function writeOpaJourneyTypes(writeContext) {
+    const { config, rootV4TemplateDirPath, testOutDirPath, editor } = writeContext;
+    editor.copyTpl(join(rootV4TemplateDirPath, 'integration', 'types', 'OpaJourneyTypes.d.ts'), join(testOutDirPath, 'integration', 'types', 'OpaJourneyTypes.d.ts'), config, undefined, {
         globOptions: { dot: true }
     });
 }
 /**
  * Checks whether a page object file already exists for the given feature name.
- * If it doesn't exist, finds the matching page config and writes the file.
+ * Both `.ts` and `.js` extensions are checked to avoid creating duplicate page objects
+ * when regenerating in a different language than the existing tests use.
+ * If neither exists, finds the matching page config and writes the file.
  *
  * @param featureName - the feature/page name (equals the manifest targetKey)
  * @param config - the OPA config containing all page configurations
  * @param rootV4TemplateDirPath - template root directory for v4 templates
  * @param testOutDirPath - output test directory (.../webapp/test)
  * @param editor - a reference to a mem-fs editor
+ * @param dotFileExtension - file extension ('.ts' or '.js')
  * @returns JourneyRunnerPage if the page was newly created, undefined otherwise
  */
-function ensurePageExists(featureName, config, rootV4TemplateDirPath, testOutDirPath, editor) {
-    const pageFilePath = join(testOutDirPath, 'integration', 'pages', `${featureName}.js`);
-    if (editor.exists(pageFilePath)) {
+function ensurePageExists(featureName, config, rootV4TemplateDirPath, testOutDirPath, editor, dotFileExtension) {
+    const pagesDir = join(testOutDirPath, 'integration', 'pages');
+    if (editor.exists(join(pagesDir, `${featureName}${DotFileExtension.TS}`)) ||
+        editor.exists(join(pagesDir, `${featureName}${DotFileExtension.JS}`))) {
         return undefined;
     }
     const pageConfig = config.pages.find((p) => p.targetKey === featureName);
     if (pageConfig) {
-        writePageObject(pageConfig, rootV4TemplateDirPath, testOutDirPath, editor);
-        return { targetKey: featureName, appPath: config.appPath };
+        writePageObject(pageConfig, rootV4TemplateDirPath, testOutDirPath, editor, dotFileExtension);
+        return {
+            targetKey: featureName,
+            appPath: config.appPath,
+            template: pageConfig.template,
+            appID: config.appID,
+            componentID: pageConfig.componentID,
+            entitySet: pageConfig.entitySet,
+            contextPath: pageConfig.contextPath
+        };
     }
     return undefined;
 }
@@ -360,22 +395,23 @@ function ensurePageExists(featureName, config, rootV4TemplateDirPath, testOutDir
  * @param appFeatures - object containing feature data for list report, object pages, and FPM
  * @param writeContext - shared write context (config, paths, editor, journey params)
  * @param isStandalone - whether the generation is run in standalone mode (not during app generation)
- * @param hasJourneyRunner - whether a JourneyRunner.js already exists (standalone upgrade path)
+ * @param hasJourneyRunner - whether a JourneyRunner already exists (standalone upgrade path)
  * @param virtualOPA5Configured - whether virtual OPA5 is configured
  */
 function writeJourneyFiles(appFeatures, writeContext, isStandalone, hasJourneyRunner = false, virtualOPA5Configured = false) {
-    const { config, rootV4TemplateDirPath, testOutDirPath, editor, journeyParams } = writeContext;
+    const { config, rootV4TemplateDirPath, testOutDirPath, editor, journeyParams, dotFileExtension } = writeContext;
     const generatedJourneyPages = [];
     const newPages = [];
     if (appFeatures.listReport?.name) {
-        editor.copyTpl(join(rootV4TemplateDirPath, 'integration', 'ListReportJourney.js'), join(testOutDirPath, 'integration', `${appFeatures.listReport.name}Journey.js`), {
+        editor.copyTpl(join(rootV4TemplateDirPath, 'integration', `ListReportJourney${dotFileExtension}`), join(testOutDirPath, 'integration', `${appFeatures.listReport.name}Journey${dotFileExtension}`), {
             ...journeyParams,
-            ...appFeatures.listReport
+            ...appFeatures.listReport,
+            appPath: config.appPath
         }, undefined, {
             globOptions: { dot: true }
         });
         generatedJourneyPages.push(appFeatures.listReport.name);
-        const lrPage = ensurePageExists(appFeatures.listReport.name, config, rootV4TemplateDirPath, testOutDirPath, editor);
+        const lrPage = ensurePageExists(appFeatures.listReport.name, config, rootV4TemplateDirPath, testOutDirPath, editor, dotFileExtension);
         if (lrPage) {
             newPages.push(lrPage);
         }
@@ -383,15 +419,16 @@ function writeJourneyFiles(appFeatures, writeContext, isStandalone, hasJourneyRu
     if (appFeatures.objectPages && appFeatures.objectPages.length > 0) {
         appFeatures.objectPages.forEach((objectPage) => {
             if (objectPage.name) {
-                editor.copyTpl(join(rootV4TemplateDirPath, 'integration', 'ObjectPageJourney.js'), join(testOutDirPath, 'integration', `${objectPage.name}Journey.js`), {
+                editor.copyTpl(join(rootV4TemplateDirPath, 'integration', `ObjectPageJourney${dotFileExtension}`), join(testOutDirPath, 'integration', `${objectPage.name}Journey${dotFileExtension}`), {
                     ...journeyParams,
                     ...objectPage,
-                    isStandalone
+                    isStandalone,
+                    appPath: config.appPath
                 }, undefined, {
                     globOptions: { dot: true }
                 });
                 generatedJourneyPages.push(objectPage.name);
-                const opPage = ensurePageExists(objectPage.name, config, rootV4TemplateDirPath, testOutDirPath, editor);
+                const opPage = ensurePageExists(objectPage.name, config, rootV4TemplateDirPath, testOutDirPath, editor, dotFileExtension);
                 if (opPage) {
                     newPages.push(opPage);
                 }
@@ -399,6 +436,13 @@ function writeJourneyFiles(appFeatures, writeContext, isStandalone, hasJourneyRu
         });
     }
     if (appFeatures.fpm?.name) {
+        // FPM TypeScript support is out of scope for the initial TS OPA5 work
+        // (LROP only). The FPM journey path below is hardcoded `.js` and there is
+        // no `FPM.ts` template, so we force `DotFileExtension.JS` for the FPM
+        // page-object regardless of the configured `dotFileExtension`. Otherwise
+        // an LR-OP-FPM mix with `enableTypeScript` would crash in `writePageObject`
+        // when trying to load the missing `FPM.ts` template.
+        // Future work: add FPM.ts/FPMJourney.ts templates and switch to `dotFileExtension`.
         editor.copyTpl(join(rootV4TemplateDirPath, 'integration', 'FPMJourney.js'), join(testOutDirPath, 'integration', `${appFeatures.fpm.name}Journey.js`), {
             ...journeyParams,
             ...appFeatures.fpm
@@ -406,13 +450,13 @@ function writeJourneyFiles(appFeatures, writeContext, isStandalone, hasJourneyRu
             globOptions: { dot: true }
         });
         generatedJourneyPages.push(appFeatures.fpm.name);
-        const fpmPage = ensurePageExists(appFeatures.fpm.name, config, rootV4TemplateDirPath, testOutDirPath, editor);
+        const fpmPage = ensurePageExists(appFeatures.fpm.name, config, rootV4TemplateDirPath, testOutDirPath, editor, DotFileExtension.JS);
         if (fpmPage) {
             newPages.push(fpmPage);
         }
     }
     if (newPages.length > 0) {
-        addPagesToJourneyRunner(newPages, testOutDirPath, editor);
+        addPagesToJourneyRunner(newPages, testOutDirPath, editor, dotFileExtension);
     }
     if (!virtualOPA5Configured) {
         if (hasJourneyRunner) {
@@ -434,9 +478,12 @@ function writeJourneyFiles(appFeatures, writeContext, isStandalone, hasJourneyRu
  * @param rootTemplateDirPath - template root directory
  * @param testOutDirPath - output test directory (.../webapp/test)
  * @param fs - a reference to a mem-fs editor
+ * @param dotFileExtension - file extension ('.ts' or '.js')
  */
-function writePageObject(pageConfig, rootTemplateDirPath, testOutDirPath, fs) {
-    fs.copyTpl(join(rootTemplateDirPath, 'integration', 'pages', `${pageConfig.template}.js`), join(testOutDirPath, 'integration', 'pages', `${pageConfig.targetKey}.js`), pageConfig, undefined, {
+function writePageObject(pageConfig, rootTemplateDirPath, testOutDirPath, fs, dotFileExtension) {
+    // FPM has no .ts template; force .js regardless of the configured extension
+    const ext = pageConfig.template === 'FPM' ? DotFileExtension.JS : dotFileExtension;
+    fs.copyTpl(join(rootTemplateDirPath, 'integration', 'pages', `${pageConfig.template}${ext}`), join(testOutDirPath, 'integration', 'pages', `${pageConfig.targetKey}${ext}`), pageConfig, undefined, {
         globOptions: { dot: true }
     });
 }

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { generateOPAFiles } from './fiori-elements-opa-writer.js';
 export { generateFreestyleOPAFiles } from './fiori-freestyle-opa-writer.js';
 export { addVirtualTestConfig } from './utils/opaQUnitUtils.js';
+export type { OPAGenerationOptions } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/types.d.ts

@@ -1,4 +1,24 @@
 import type { Editor } from 'mem-fs-editor';
+export declare const DotFileExtension: {
+    readonly JS: ".js";
+    readonly TS: ".ts";
+};
+export type DotFileExtension = (typeof DotFileExtension)[keyof typeof DotFileExtension];
+/**
+ * Options accepted by the public OPA test generation entry point.
+ */
+export type OPAGenerationOptions = {
+    /** The name of the OPA journey file. If not specified, 'FirstJourney' will be used. */
+    scriptName?: string;
+    /** The appID. If not specified, will be read from the manifest in sap.app/id. */
+    appID?: string;
+    /** The name of the html that will be used in OPA journey file. If not specified, 'index.html' will be used. */
+    htmlTarget?: string;
+    /** When true, OPA harness files are served virtually; skip writing them to disk. */
+    useVirtualPreviewEndpoints?: boolean;
+    /** If true, generate TypeScript files instead of JavaScript. */
+    enableTypeScript?: boolean;
+};
 export declare const SupportedPageTypes: {
     [id: string]: string;
 };
@@ -193,6 +213,7 @@ export type WriteContext = {
     testOutDirPath: string;
     editor: Editor;
     journeyParams: JourneyParams;
+    dotFileExtension: DotFileExtension;
 };
 export type FormField = {
     fieldGroupQualifier?: string;

package/dist/types.js

@@ -1,3 +1,7 @@
+export const DotFileExtension = {
+    JS: '.js',
+    TS: '.ts'
+};
 export const SupportedPageTypes = {
     'sap.fe.templates.ListReport': 'ListReport',
     'sap.fe.templates.ObjectPage': 'ObjectPage',

package/dist/utils/opaQUnitUtils.d.ts

@@ -4,6 +4,7 @@
  * all other content (formatting, comments, whitespace) is preserved exactly.
  */
 import type { Editor } from 'mem-fs-editor';
+import { DotFileExtension } from '../types.js';
 import type { TestConfig as PreviewMiddlewareTestConfig } from '@sap-ux/preview-middleware';
 /**
  * Splices new module paths into the sap.ui.require array of the content string.
@@ -48,13 +49,23 @@ export declare function addIntegrationOldToGitignore(basePath: string, fs: Edito
  */
 export declare function addPathsToQUnitJs(filePaths: string[], projectPath: string, fs: Editor): void;
 /**
- * Page entry to splice into an existing JourneyRunner.js.
+ * Page entry to splice into an existing JourneyRunner.js / JourneyRunner.ts.
  */
 export interface JourneyRunnerPage {
     /** The page's targetKey, used as both the variable name and `onThe<targetKey>` key */
     targetKey: string;
     /** The app module path prefix (e.g. "project1/test/integration/pages") */
     appPath: string;
+    /** The framework page template (`'ListReport'` or `'ObjectPage'`); used by the TS splicer to construct `new <FW>(definition, Custom<Page>)`. */
+    template?: string;
+    /** The app id (sap.app.id from the manifest); only needed by the TS splicer. */
+    appID?: string;
+    /** The component id (defined in the target section); only needed by the TS splicer. */
+    componentID?: string;
+    /** The entity set name (if the page uses an entitySet rather than a contextPath); only needed by the TS splicer. */
+    entitySet?: string;
+    /** The context path (if the page uses a contextPath rather than an entitySet); only needed by the TS splicer. */
+    contextPath?: string;
 }
 /**
  * Splices new page entries into the three locations of an existing JourneyRunner.js:
@@ -74,15 +85,32 @@ export interface JourneyRunnerPage {
  */
 export declare function splicePageIntoJourneyRunner(fileContent: string, pages: JourneyRunnerPage[]): string;
 /**
- * Reads JourneyRunner.js from the project, adds new page entries to all three
- * locations (define array, function params, pages object), and writes the updated
- * content back. Pages already present are skipped.
+ * Splices new page entries into an existing TypeScript JourneyRunner.ts:
+ * - adds a default-import line after the last existing page import
+ * - adds an entry inside the `pages: { ... }` object literal
+ *
+ * Pages already present (detected by their import line) are skipped.
+ * All other content — formatting, comments, whitespace — is preserved exactly.
+ *
+ * Note: files exceeding MAX_FILE_CONTENT_LENGTH characters are returned unchanged to prevent
+ * ReDoS on crafted inputs. Valid generated files are well within this limit.
+ *
+ * @param fileContent - the full content of the JourneyRunner.ts file
+ * @param pages - pages to add
+ * @returns the updated file content, or the original content unchanged if nothing was added
+ */
+export declare function splicePageIntoJourneyRunnerTs(fileContent: string, pages: JourneyRunnerPage[]): string;
+/**
+ * Reads JourneyRunner from the project, adds new page entries, and writes the updated
+ * content back. Pages already present are skipped. Both AMD (`.js`) and ES module
+ * (`.ts`) variants are supported and dispatched on `dotFileExtension`.
  *
  * @param pages - pages to add
  * @param testOutDirPath - path to the test output directory (`.../webapp/test`)
  * @param fs - mem-fs-editor instance used to read and write the file
+ * @param dotFileExtension - file extension of the JourneyRunner ('.ts' or '.js'); defaults to '.js'
  */
-export declare function addPagesToJourneyRunner(pages: JourneyRunnerPage[], testOutDirPath: string, fs: Editor): void;
+export declare function addPagesToJourneyRunner(pages: JourneyRunnerPage[], testOutDirPath: string, fs: Editor, dotFileExtension?: DotFileExtension): void;
 /**
  * Returns true if any UI5 yaml file in the project contains a `fiori-tools-preview`
  * middleware whose `test` array includes an entry with `framework: OPA5`.

package/dist/utils/opaQUnitUtils.js

@@ -6,6 +6,7 @@
 import { join } from 'node:path';
 import { readHashFromFlpSandbox } from './flpSandboxUtils.js';
 import { getAllUi5YamlFileNames, readUi5Yaml, FileName } from '@sap-ux/project-access';
+import { DotFileExtension } from '../types.js';
 /** Relative path from the test output directory to opaTests.qunit.js */
 const OPA_QUNIT_FILE = join('integration', 'opaTests.qunit.js');
 /**
@@ -25,6 +26,13 @@ const OPA_QUNIT_FILE = join('integration', 'opaTests.qunit.js');
 const SAP_UI_REQUIRE_ARRAY_REGEX = /sap\.ui\.require\s*\(\s*\[([^\]]*)\]\s*,\s*function/d;
 /** ReDoS mitigation: files larger than this are returned unchanged rather than matched with regex. */
 const MAX_FILE_CONTENT_LENGTH = 10000;
+/**
+ * Escapes regex metacharacters in a string so it can be safely embedded in a `RegExp` pattern.
+ *
+ * @param value - the string to escape
+ * @returns the escaped string
+ */
+const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, String.raw `\$&`);
 /**
  * Splices new module paths into the sap.ui.require array of the content string.
  * Entries that are already present are skipped. All other content is preserved exactly.
@@ -161,8 +169,13 @@ export function addPathsToQUnitJs(filePaths, projectPath, fs) {
         // If the file doesn't exist or can't be read, do nothing
     }
 }
-/** Relative path from the test output directory to JourneyRunner.js */
-const JOURNEY_RUNNER_FILE = join('integration', 'pages', 'JourneyRunner.js');
+/**
+ * Builds the relative path from the test output directory to the JourneyRunner file.
+ *
+ * @param dotFileExtension - file extension ('.ts' or '.js')
+ * @returns the relative path
+ */
+const getJourneyRunnerFilePath = (dotFileExtension) => join('integration', 'pages', `JourneyRunner${dotFileExtension}`);
 /**
  * Splices new page entries into the three locations of an existing JourneyRunner.js:
  * - the sap.ui.define dependency array
@@ -246,19 +259,187 @@ export function splicePageIntoJourneyRunner(fileContent, pages) {
     return result;
 }
 /**
- * Reads JourneyRunner.js from the project, adds new page entries to all three
- * locations (define array, function params, pages object), and writes the updated
- * content back. Pages already present are skipped.
+ * Filters the input page list down to those whose `Custom<targetKey>` import line is not yet
+ * present in the existing JourneyRunner.ts content.
+ *
+ * @param fileContent - the existing JourneyRunner.ts content
+ * @param pages - the candidate pages to splice in
+ * @returns the subset of pages that need to be added
+ */
+function findPagesToAdd(fileContent, pages) {
+    return pages.filter((page) => {
+        const importPattern = new RegExp(String.raw `from\s+"\./${escapeRegex(page.targetKey)}"`);
+        return !importPattern.test(fileContent);
+    });
+}
+/**
+ * Returns the offset of the character immediately after the last `import ... from "..."` line in
+ * the given content, or -1 if no import line is found.
+ *
+ * Uses `\b` word boundaries (zero-width) around `import` and `from` so the `[^\n]*?` middle
+ * quantifier doesn't sit next to another quantifier that could match the same characters. This
+ * avoids the consecutive-overlapping-quantifier shape that triggers catastrophic backtracking.
+ *
+ * @param content - the file content to scan
+ * @returns the index immediately after the last import line, or -1 if none found
+ */
+function findLastImportEnd(content) {
+    const importLineRegex = /^import\b[^\n]*?\bfrom[ \t]+["'][^"']+["'];?[ \t]*$/gm;
+    let lastImportEnd = -1;
+    let importMatch;
+    while ((importMatch = importLineRegex.exec(content)) !== null) {
+        lastImportEnd = importMatch.index + importMatch[0].length;
+    }
+    return lastImportEnd;
+}
+/**
+ * Walks forward from the opening `{` of a `pages: { ... }` object literal, counting braces, and
+ * returns the index of the matching closing `}`. The pages object now contains nested `{}` (the
+ * page-definition object) so a regex with `[^}]*` would stop at the first inner closing brace.
+ *
+ * @param content - the file content
+ * @param openBraceIdx - the index of the `{` that opens the pages object
+ * @returns the index of the matching closing `}` (or `content.length` if not found)
+ */
+function findMatchingClosingBrace(content, openBraceIdx) {
+    let depth = 1;
+    let i = openBraceIdx + 1;
+    while (i < content.length && depth > 0) {
+        const ch = content[i];
+        if (ch === '{') {
+            depth++;
+        }
+        else if (ch === '}') {
+            depth--;
+        }
+        if (depth === 0) {
+            break;
+        }
+        i++;
+    }
+    return i;
+}
+/**
+ * Builds the source-code block for a single new entry in the `pages: { ... }` object literal.
+ *
+ * @param page - the page to render
+ * @param pageIndent - leading whitespace for the entry's outer line
+ * @param innerIndent - leading whitespace for the entry's nested lines
+ * @returns the multi-line source block
+ */
+function buildPageEntry(page, pageIndent, innerIndent) {
+    const fw = page.template ?? 'ListReport';
+    return [
+        `${pageIndent}onThe${page.targetKey}: new ${fw}(`,
+        `${innerIndent}{`,
+        `${innerIndent}    appId: "${page.appID ?? ''}",`,
+        `${innerIndent}    componentId: "${page.componentID ?? ''}",`,
+        `${innerIndent}    entitySet: "${page.entitySet ?? ''}",`,
+        `${innerIndent}    contextPath: "${page.contextPath ?? ''}"`,
+        `${innerIndent}},`,
+        `${innerIndent}Custom${page.targetKey}`,
+        `${pageIndent})`
+    ].join('\n');
+}
+/**
+ * Inserts the given import lines after the last existing `import` line in `content`. If `content`
+ * has no `import` lines, returns it unchanged.
+ *
+ * @param content - the file content
+ * @param newImportLines - the import lines to insert (each should NOT include a leading newline)
+ * @returns the updated content
+ */
+function insertAfterLastImport(content, newImportLines) {
+    if (newImportLines.length === 0) {
+        return content;
+    }
+    const lastImportEnd = findLastImportEnd(content);
+    if (lastImportEnd < 0) {
+        return content;
+    }
+    const newImports = newImportLines.map((line) => `\n${line}`).join('');
+    return `${content.slice(0, lastImportEnd)}${newImports}${content.slice(lastImportEnd)}`;
+}
+/**
+ * Inserts the given new page entries inside the `pages: { ... }` object literal of `content`. If
+ * `content` has no `pages: {` block, returns it unchanged.
+ *
+ * @param content - the file content
+ * @param toAdd - the pages to add
+ * @returns the updated content
+ */
+function insertIntoPagesObject(content, toAdd) {
+    const pagesStartMatch = /pages\s*:\s*\{/.exec(content);
+    if (!pagesStartMatch) {
+        return content;
+    }
+    const openBraceIdx = content.indexOf('{', pagesStartMatch.index);
+    const pagesBodyEnd = findMatchingClosingBrace(content, openBraceIdx);
+    const pagesBody = content.slice(openBraceIdx + 1, pagesBodyEnd);
+    // Detect indentation from the first existing page entry
+    const pageIndentMatch = /^([ \t]+)on/m.exec(pagesBody);
+    const pageIndent = pageIndentMatch ? pageIndentMatch[1] : '        ';
+    const innerIndent = pageIndent + '    ';
+    const newPageEntries = toAdd.map((page) => buildPageEntry(page, pageIndent, innerIndent)).join(',\n');
+    // Ensure the last existing entry ends with a comma before we insert after it.
+    const trimmedPagesEnd = content.slice(0, pagesBodyEnd).trimEnd();
+    const needsComma = !trimmedPagesEnd.endsWith(',') && !trimmedPagesEnd.endsWith('{');
+    const commaFix = needsComma ? ',' : '';
+    const trailingWhitespace = content.slice(trimmedPagesEnd.length, pagesBodyEnd);
+    return `${trimmedPagesEnd}${commaFix}\n${newPageEntries}${trailingWhitespace}${content.slice(pagesBodyEnd)}`;
+}
+/**
+ * Splices new page entries into an existing TypeScript JourneyRunner.ts:
+ * - adds a default-import line after the last existing page import
+ * - adds an entry inside the `pages: { ... }` object literal
+ *
+ * Pages already present (detected by their import line) are skipped.
+ * All other content — formatting, comments, whitespace — is preserved exactly.
+ *
+ * Note: files exceeding MAX_FILE_CONTENT_LENGTH characters are returned unchanged to prevent
+ * ReDoS on crafted inputs. Valid generated files are well within this limit.
+ *
+ * @param fileContent - the full content of the JourneyRunner.ts file
+ * @param pages - pages to add
+ * @returns the updated file content, or the original content unchanged if nothing was added
+ */
+export function splicePageIntoJourneyRunnerTs(fileContent, pages) {
+    if (fileContent.length > MAX_FILE_CONTENT_LENGTH) {
+        return fileContent;
+    }
+    const toAdd = findPagesToAdd(fileContent, pages);
+    if (toAdd.length === 0) {
+        return fileContent;
+    }
+    // Determine which framework imports (ListReport / ObjectPage) are missing and need to be added.
+    const frameworkTemplates = Array.from(new Set(toAdd.map((page) => page.template).filter((t) => Boolean(t))));
+    const missingFrameworkImports = frameworkTemplates.filter((tpl) => !fileContent.includes(`from "sap/fe/test/${tpl}"`));
+    const newImportLines = [
+        ...missingFrameworkImports.map((tpl) => `import ${tpl} from "sap/fe/test/${tpl}";`),
+        ...toAdd.map((page) => `import Custom${page.targetKey} from "./${page.targetKey}";`)
+    ];
+    const withImports = insertAfterLastImport(fileContent, newImportLines);
+    return insertIntoPagesObject(withImports, toAdd);
+}
+/**
+ * Reads JourneyRunner from the project, adds new page entries, and writes the updated
+ * content back. Pages already present are skipped. Both AMD (`.js`) and ES module
+ * (`.ts`) variants are supported and dispatched on `dotFileExtension`.
  *
  * @param pages - pages to add
  * @param testOutDirPath - path to the test output directory (`.../webapp/test`)
  * @param fs - mem-fs-editor instance used to read and write the file
+ * @param dotFileExtension - file extension of the JourneyRunner ('.ts' or '.js'); defaults to '.js'
  */
-export function addPagesToJourneyRunner(pages, testOutDirPath, fs) {
+export function addPagesToJourneyRunner(pages, testOutDirPath, fs, dotFileExtension = DotFileExtension.JS) {
+    if (pages.length === 0) {
+        return;
+    }
     try {
-        const filePath = join(testOutDirPath, JOURNEY_RUNNER_FILE);
+        const filePath = join(testOutDirPath, getJourneyRunnerFilePath(dotFileExtension));
         const content = fs.read(filePath);
-        const updated = splicePageIntoJourneyRunner(content, pages);
+        const splice = dotFileExtension === DotFileExtension.TS ? splicePageIntoJourneyRunnerTs : splicePageIntoJourneyRunner;
+        const updated = splice(content, pages);
         if (updated !== content) {
             fs.write(filePath, updated);
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sap-ux/ui5-test-writer",
   "description": "SAP UI5 tests writer",
-  "version": "1.0.14",
+  "version": "1.1.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/SAP/open-ux-tools.git",
@@ -30,9 +30,9 @@
     "@sap-ux/annotation-converter": "0.10.21",
     "@sap-ux/ui5-application-writer": "2.0.3",
     "@sap-ux/logger": "1.0.1",
+    "@sap-ux/fiori-generator-shared": "1.0.9",
     "@sap-ux/project-access": "2.1.2",
-    "@sap-ux/preview-middleware": "1.0.14",
-    "@sap-ux/fiori-generator-shared": "1.0.9"
+    "@sap-ux/preview-middleware": "1.0.14"
   },
   "devDependencies": {
     "@jest/globals": "30.3.0",

package/templates/v4/integration/FirstJourney.ts

@@ -0,0 +1,32 @@
+import opaTest from "sap/ui/test/opaQunit";
+import type { Given, When, Then } from "./types/OpaJourneyTypes";
+import runner from "./pages/JourneyRunner";
+
+function journey() {
+    QUnit.module("First journey");
+
+    opaTest("Start application", function (Given: Given, _When: When<% if (startLR) { %>, Then: Then<% } else { %>, _Then: Then<% } %>) {
+        Given.iStartMyApp();
+        <% if (startLR) { %>Then.onThe<%- startLR %>.iSeeThisPage();<%} %>
+    });
+
+<% if (startLR) { %>
+    opaTest("Navigate to ObjectPage", function (_Given: Given, When: When, Then: Then) {
+        // Note: this test will fail if the ListReport page doesn't show any data
+        <% if (!hideFilterBar) { %>
+        When.onThe<%- startLR%>.onFilterBar().iExecuteSearch();
+        <%} %>
+        Then.onThe<%- startLR%>.onTable("").iCheckRows();
+<% if (navigatedOP) { %>
+        When.onThe<%- startLR%>.onTable("").iPressRow(0);
+        Then.onThe<%- navigatedOP%>.iSeeThisPage();
+<%} %>
+    });
+<%} %>
+    opaTest("Teardown", function (Given: Given) {
+        // Cleanup
+        Given.iTearDownMyApp();
+    });
+}
+
+runner.run([journey]);

package/templates/v4/integration/ListReportJourney.ts

@@ -0,0 +1,117 @@
+/******************************************************************************
+ * ╔═══════════════════════════════════════════════════════════════════════╗ *
+ * ║                                                                       ║ *
+ * ║   WARNING: AUTO-GENERATED FILE                                        ║ *
+ * ║                                                                       ║ *
+ * ║   This file is automatically generated by SAP Fiori tools and is      ║ *
+ * ║   overwritten when you run the OPA test generator again.              ║ *
+ * ║                                                                       ║ *
+ * ║   To add your own custom tests:                                       ║ *
+ * ║   - Create a new journey test file in this directory.                 ║ *
+ * ║   - Follow the same pattern as this file.                             ║ *
+ * ║   - Add the new file to the opaTests.qunit.js config file.            ║ *
+ * ║   - Custom journey files are not overwritten.                         ║ *
+ * ║                                                                       ║ *
+ * ╚═══════════════════════════════════════════════════════════════════════╝ *
+ ******************************************************************************/
+
+import opaTest from "sap/ui/test/opaQunit";
+import type { Given, When, Then } from "./types/OpaJourneyTypes";
+<%_
+const usesFilterFieldIdentifier =
+    (!hideFilterBar && filterBarItems && filterBarItems.length > 0) ||
+    (semanticKey && semanticKey.missingFromFilterBar && semanticKey.missingFromFilterBar.length > 0);
+-%>
+<% if (usesFilterFieldIdentifier) { -%>
+import type { FilterFieldIdentifier } from "sap/fe/test/api/FilterBarAPI";
+<% } -%>
+import runner from "./pages/JourneyRunner";
+
+function journey() {
+    QUnit.module("<%- name%>ListReport journey");
+
+    opaTest("Start application", function (Given: Given, _When: When, Then: Then) {
+        Given.iStartMyApp();
+        <%_ startPages.forEach(function(pageName) { %>
+        Then.onThe<%- pageName %>.iSeeThisPage();
+        <%_ }); -%>
+    });
+
+    <%_ if (!hideFilterBar && filterBarItems && filterBarItems.length > 0) { -%>
+    opaTest("Check filter bar", function (_Given: Given, _When: When, Then: Then) {
+        <%_ filterBarItems.forEach(function(item) { _%>
+        Then.onThe<%- startLR%>.onFilterBar().iCheckFilterField("<%- item %>" as unknown as FilterFieldIdentifier);
+        <%_ }); -%>
+    });
+<%_ } -%>
+<%_ if (semanticKey && semanticKey.missingFromFilterBar && semanticKey.missingFromFilterBar.length > 0) { %>
+    opaTest("Add semantic key properties to filter bar", function (_Given: Given, When: When, Then: Then) {
+        Then.onThe<%- startLR%>.onFilterBar().iOpenFilterAdaptation();
+        <%_ semanticKey.missingFromFilterBar.forEach(function(property) { _%>
+        When.onThe<%- startLR%>.onFilterBar().iAddAdaptationFilterField("<%- property %>");
+        <%_ }); -%>
+        Then.onThe<%- startLR%>.onFilterBar().iConfirmFilterAdaptation();
+        <%_ semanticKey.missingFromFilterBar.forEach(function(property) { _%>
+        Then.onThe<%- startLR%>.onFilterBar().iCheckFilterField("<%- property %>" as unknown as FilterFieldIdentifier);
+        <%_ }); -%>
+        <%_ semanticKey.missingFromFilterBar.forEach(function(property) { _%>
+        // Then.onThe<%- startLR%>.onFilterBar().iChangeFilterField({ property: "<%- property %>" });
+        <%_ }); -%>
+        // Then.onThe<%- startLR%>.onFilterBar().iExecuteSearch();
+        // Then.onThe<%- startLR%>.onTable("").iCheckRows();
+        // Then.onThe<%- startLR%>.onTable("").iSelectRows(0);
+        // Then.onThe<%- startLR%>.onTable("").iCheckAction("<Action Name>", { enabled: true });
+    });
+<%_ } -%>
+
+    // Note: this test will only work if the ListReport page has a search field and shows data that matches the search term. Please ensure that the test data and search term are set up accordingly.
+    // opaTest("Perform a global search and check the result", function (Given: Given, When: When, Then: Then) {
+    //     When.onThe<%- startLR%>.onFilterBar().iChangeSearchField("Search Term");
+    //     When.onThe<%- startLR%>.onFilterBar().iExecuteSearch();
+    //     Then.onThe<%- startLR%>.onTable("").iCheckRows();
+    // });
+
+<%_ if ((toolBarActions && toolBarActions.length > 0 ) || (tableColumns && Object.keys(tableColumns).length > 0)) { -%>
+    opaTest("Check table columns and actions", function (_Given: Given, _When: When, Then: Then) {
+        <%_ if (toolBarActions && toolBarActions.length > 0) { -%>
+        <%_ if (createButton.visible && !isALP) { _%>
+        Then.onThe<%- startLR%>.onTable("").iCheckCreate({ visible: true });
+        // Then.onthe<%- startLR%>.onTable("").iPressCreate();
+        <%_ } _%>
+        <%_ if (deleteButton.visible) { _%>
+        // Then.onthe<%- startLR%>.onTable("").iPressDelete();
+        Then.onThe<%- startLR%>.onTable("").iCheckDelete({ visible: true });
+        <%_ } _%>
+        <%_ toolBarActions.forEach(function(item) { _%>
+        <%_ if (item.visible) { _%>
+        // Then.onThe<%- startLR%>.onTable("").iPressAction("<%- item.label %>");
+        Then.onThe<%- startLR%>.onTable("").iCheckAction("<%- item.label %>", { enabled: <%- item.enabled === true %> });
+        <%_ } _%>
+        <%_ }); -%>
+        <%_ } -%>
+        <%_ if (tableColumns && Object.keys(tableColumns).length > 0) { -%>
+        Then.onThe<%- startLR %>.onTable("").iCheckColumns(undefined, <%- JSON.stringify(tableColumns) %>);
+        <%_ } %>
+    });
+<%_ } %>
+
+<% if (startLR) { %>
+    opaTest("Navigate to ObjectPage", function (_Given: Given, When: When, Then: Then) {
+        // Note: this test will fail if the ListReport page doesn't show any data
+        <% if (!hideFilterBar) { %>
+        When.onThe<%- startLR%>.onFilterBar().iExecuteSearch();
+        <%} %>
+        Then.onThe<%- startLR%>.onTable("").iCheckRows();
+<% if (navigatedOP) { %>
+        When.onThe<%- startLR%>.onTable("").iPressRow(0);
+        Then.onThe<%- navigatedOP%>.iSeeThisPage();
+<%} %>
+    });
+<%} %>
+    opaTest("Teardown", function (Given: Given) {
+        // Cleanup
+        Given.iTearDownMyApp();
+    });
+}
+
+runner.run([journey]);

package/templates/v4/integration/ObjectPageJourney.ts

@@ -0,0 +1,176 @@
+/******************************************************************************
+ * ╔═══════════════════════════════════════════════════════════════════════╗ *
+ * ║                                                                       ║ *
+ * ║   WARNING: AUTO-GENERATED FILE                                        ║ *
+ * ║                                                                       ║ *
+ * ║   This file is automatically generated by SAP Fiori tools and is      ║ *
+ * ║   overwritten when you run the OPA test generator again.              ║ *
+ * ║                                                                       ║ *
+ * ║   To add your own custom tests:                                       ║ *
+ * ║   - Create a new journey test file in this directory.                 ║ *
+ * ║   - Follow the same pattern as this file.                             ║ *
+ * ║   - Add the new file to the opaTests.qunit.js config file.            ║ *
+ * ║   - Custom journey files are not overwritten.                         ║ *
+ * ║                                                                       ║ *
+ * ╚═══════════════════════════════════════════════════════════════════════╝ *
+ ******************************************************************************/
+
+import opaTest from "sap/ui/test/opaQunit";
+import type { Given, When, Then } from "./types/OpaJourneyTypes";
+<%_
+const usesFieldIdentifier = (headerSections || []).some(function(section) {
+    return section.form && section.fields && section.fields.length > 0;
+});
+const usesFormIdentifier = !isStandalone && (bodySections || []).some(function(section) {
+    const subSectionsHaveForm = (section.subSections || []).some(function(sub) {
+        return sub.fields && sub.fields.length > 0;
+    });
+    const sectionHasFormFields = !(section.subSections && section.subSections.length > 0) && section.fields && section.fields.length > 0;
+    const hasFormAction = (section.actions || []).some(function(action) {
+        return action.visible && !(section.isTable && section.navigationProperty);
+    });
+    return subSectionsHaveForm || sectionHasFormFields || hasFormAction;
+});
+-%>
+<% if (usesFieldIdentifier) { -%>
+import type { FieldIdentifier } from "sap/fe/test/api/BaseAPI";
+<% } -%>
+<% if (usesFormIdentifier) { -%>
+import type { FormIdentifier } from "sap/fe/test/api/FormAPI";
+<% } -%>
+import runner from "./pages/JourneyRunner";
+
+function journey() {
+    QUnit.module("<%- name%>ObjectPage journey");
+
+    opaTest("Navigate to <%- name%>ObjectPage", function (Given: Given, When: When, Then: Then) {
+        Given.iStartMyApp();
+<% if (!hideFilterBar) { %>
+        When.onThe<%- navigationParents.parentLRName%>.onFilterBar().iExecuteSearch();
+<% } %>
+        Then.onThe<%- navigationParents.parentLRName%>.onTable("").iCheckRows();
+        When.onThe<%- navigationParents.parentLRName%>.onTable("").iPressRow(0);
+<% if(navigationParents.parentOPName) { %>
+        Then.onThe<%- navigationParents.parentOPName%>.iSeeThisPage();
+        Then.onThe<%- navigationParents.parentOPName%>.onTable({ property: "<%- navigationParents.parentOPTableSection %>" }).iCheckRows();
+        When.onThe<%- navigationParents.parentOPName%>.onTable({ property: "<%- navigationParents.parentOPTableSection %>" }).iPressRow(0);
+<% } %>
+        Then.onThe<%- name%>.iSeeThisPage();
+    });
+
+<% if (headerActions?.length > 0 && !isStandalone) { -%>
+    opaTest("Check header actions of the Object Page", function (_Given: Given, _When: When, Then: Then) {
+<% if (editButton?.visible) { -%>
+        // Ensure the opened entity is not in Draft state before uncommenting
+        // Then.onThe<%- name%>.onHeader().iCheckEdit({ visible: true });
+        // When.onThe<%- name%>.onHeader().iPressEdit();
+<% } -%>
+<%     headerActions.forEach(function(action) { -%>
+<%     if (action.visible) { -%>
+<%         if (action.enabled === 'dynamic') { -%>
+        Then.onThe<%- name%>.onHeader().iCheckAction("<%- action.label %>" /* , { enabled: true } */);
+<%         } else { -%>
+        Then.onThe<%- name%>.onHeader().iCheckAction("<%- action.label %>", { enabled: <%- action.enabled === true %> });
+<%         } -%>
+        // When.onThe<%- name%>.onHeader().iPressAction("<%- action.label %>");
+<%     } -%>
+<%     }); -%>
+    });
+<% } -%>
+
+<% if (headerSections?.length > 0) { -%>
+    opaTest("Check header facets of the Object Page", function (_Given: Given, _When: When, Then: Then) {
+<% headerSections.forEach(function(section) { -%>
+<% if (section.microChart) { -%>
+        Then.onThe<%- name%>.onHeader().iCheckMicroChart("<%- section.title %>", "");
+<% } else { -%>
+        Then.onThe<%- name%>.onHeader().iCheckHeaderFacet({ facetId: "<%- section.facetId %>" });
+<% if (section.form) { -%>
+<% section.fields.forEach(function(field) { -%>
+        Then.onThe<%- name%>.onHeader().iCheckFieldInFieldGroup({
+            fieldGroup: "FieldGroup::<%- field.fieldGroupQualifier %>",
+            field: "<%- field.field %>",
+            targetAnnotation: "<%- field.targetAnnotation %>"
+        } as unknown as FieldIdentifier);
+<% }) -%>
+<% } -%>
+<% } -%>
+<% }) -%>
+    });
+<% } -%>
+
+<% if (bodySections?.length > 0 && !isStandalone) { -%>
+    opaTest("Check body sections of the Object Page", function (_Given: Given, <% if (bodySections?.length > 1) { %>When: When<% } else { %>_When: When<% } %>, Then: Then) {
+<% if (bodySections?.length > 1) { -%>
+        Then.onThe<%- name%>.iCheckNumberOfSections(<%- bodySections.length %>);
+<% } -%>
+<% bodySections.forEach(function(section) { -%>
+<% if (bodySections.length > 1) { -%>
+        When.onThe<%- name%>.iPressSectionIconTabFilterButton("<%- section.id %>");
+<% } -%>
+        Then.onThe<%- name%>.iCheckSection({ section: "<%- section.id %>" }, {});
+<%  if (section.actions && section.actions.length > 0) { -%>
+<%      section.actions.forEach(function(action) { -%>
+<%      if (action.visible) { -%>
+<%          if (section.isTable && section.navigationProperty) { -%>
+<%              if (action.enabled === 'dynamic') { -%>
+        Then.onThe<%- name%>.onTable({ property: "<%- section.navigationProperty %>" }).iCheckAction("<%- action.label %>" /* , { enabled: true } */);
+<%              } else { -%>
+        Then.onThe<%- name%>.onTable({ property: "<%- section.navigationProperty %>" }).iCheckAction("<%- action.label %>", { enabled: <%- action.enabled === true %> });
+<%              } -%>
+        // When.onThe<%- name%>.onTable({ property: "<%- section.navigationProperty %>" }).iPressAction("<%- action.label %>");
+<%          } else { -%>
+<%              if (action.enabled === 'dynamic') { -%>
+        Then.onThe<%- name%>.onForm({ section: "<%- section.id %>" } as unknown as FormIdentifier).iCheckAction("<%- action.label %>" /* , { enabled: true } */);
+<%              } else { -%>
+        Then.onThe<%- name%>.onForm({ section: "<%- section.id %>" } as unknown as FormIdentifier).iCheckAction("<%- action.label %>", { enabled: <%- action.enabled === true %> });
+<%              } -%>
+        // When.onThe<%- name%>.onForm({ section: "<%- section.id %>" } as unknown as FormIdentifier).iPressAction("<%- action.label %>");
+<%          } -%>
+<%      } -%>
+<%      }); -%>
+<%  } -%>
+<% if (section.isTable && section.navigationProperty) { -%>
+<% if (section.createButton?.visible) { -%>
+        Then.onThe<%- name%>.onTable({ property: "<%- section.navigationProperty %>" }).iCheckCreate({ visible: true });
+        // When.onThe<%- name%>.onTable({ property: "<%- section.navigationProperty %>" }).iPressCreate();
+<% } -%>
+<% if (section.deleteButton?.visible) { -%>
+        Then.onThe<%- name%>.onTable({ property: "<%- section.navigationProperty %>" }).iCheckDelete({ visible: true });
+        // When.onThe<%- name%>.onTable({ property: "<%- section.navigationProperty %>" }).iPressDelete();
+<% } -%>
+<% } -%>
+<% if (section?.subSections?.length > 0) { -%>
+<% section.subSections.forEach(function(subSection) { -%>
+        //When.onThe<%- name%>.iGoToSection({ section: "<%- section.id %>", subSection: "<%- subSection.id %>" });
+        Then.onThe<%- name%>.iCheckSubSection({ section: "<%- subSection.id %>" });
+<% if (subSection.fields && subSection.fields.length > 0) { -%>
+<% subSection.fields.forEach(function(field) { -%>
+        Then.onThe<%- name%>.onForm({ section: "<%- subSection.id %>" } as unknown as FormIdentifier).iCheckField({ property: "<%- field.property %>" });
+<% }) -%>
+<% } -%>
+<% if (subSection.tableColumns && Object.keys(subSection.tableColumns).length > 0 && subSection.navigationProperty) { -%>
+        Then.onThe<%- name%>.onTable({ property: "<%- subSection.navigationProperty %>" }).iCheckColumns(<%- JSON.stringify(subSection.tableColumns) %>);
+<% } -%>
+<% }) -%>
+<% } else { -%>
+<% if (section.fields && section.fields.length > 0) { -%>
+<% section.fields.forEach(function(field) { -%>
+        Then.onThe<%- name%>.onForm({ section: "<%- section.id %>" } as unknown as FormIdentifier).iCheckField({ property: "<%- field.property %>" });
+<% }) -%>
+<% } -%>
+<% if (section.tableColumns && Object.keys(section.tableColumns).length > 0 && section.navigationProperty) { -%>
+        Then.onThe<%- name%>.onTable({ property: "<%- section.navigationProperty %>" }).iCheckColumns(<%- JSON.stringify(section.tableColumns) %>);
+<% } -%>
+<% } -%>
+<% }) -%>
+   });
+<% } -%>
+
+    opaTest("Teardown", function (Given: Given) {
+        // Cleanup
+        Given.iTearDownMyApp();
+    });
+}
+
+runner.run([journey]);

package/templates/v4/integration/pages/JourneyRunner.ts

@@ -0,0 +1,28 @@
+import JourneyRunner from "sap/fe/test/JourneyRunner";
+<% if (pages.some((p) => p.template === 'ListReport')) { -%>
+import ListReport from "sap/fe/test/ListReport";
+<% } -%>
+<% if (pages.some((p) => p.template === 'ObjectPage')) { -%>
+import ObjectPage from "sap/fe/test/ObjectPage";
+<% } -%>
+<%- pages.map((page) => 'import Custom' + page.targetKey + ' from "./' + page.targetKey + '";').join('\n') %>
+
+const runner = new JourneyRunner({
+    launchUrl: sap.ui.require.toUrl("<%- appPath %>") + "/<%- htmlTarget %>",
+    pages: {
+<%- pages.map((page) =>
+'        onThe' + page.targetKey + ': new ' + page.template + '(\n' +
+'            {\n' +
+'                appId: "' + page.appID + '",\n' +
+'                componentId: "' + page.componentID + '",\n' +
+'                entitySet: "' + (page.entitySet || '') + '",\n' +
+'                contextPath: "' + (page.contextPath || '') + '"\n' +
+'            },\n' +
+'            Custom' + page.targetKey + '\n' +
+'        )'
+).join(',\n') %>
+    },
+    async: true
+});
+
+export default runner;

package/templates/v4/integration/pages/ListReport.ts

@@ -0,0 +1,8 @@
+export const actions = {};
+
+export const assertions = {};
+
+export default class ListReport {
+    actions = actions;
+    assertions = assertions;
+}

package/templates/v4/integration/pages/ObjectPage.ts

@@ -0,0 +1,18 @@
+import type Opa5 from "sap/ui/test/Opa5";
+import Press from "sap/ui/test/actions/Press";
+
+export const actions = {
+    iPressSectionIconTabFilterButton(this: Opa5, section: string) {
+        return this.waitFor({
+            id: new RegExp(`.*--fe::FacetSection::${section}-anchor$`),
+            actions: new Press()
+        });
+    }
+};
+
+export const assertions = {};
+
+export default class ObjectPage {
+    actions = actions;
+    assertions = assertions;
+}

package/templates/v4/integration/types/OpaJourneyTypes.d.ts

@@ -0,0 +1,43 @@
+import type Opa5 from "sap/ui/test/Opa5";
+<% if (pages.some(p => p.template === 'ListReport')) { -%>
+import type { actions as ListReportActions, assertions as ListReportAssertions } from "sap/fe/test/ListReport";
+<% } -%>
+<% if (pages.some(p => p.template === 'ObjectPage')) { -%>
+import type { actions as ObjectPageActions, assertions as ObjectPageAssertions } from "sap/fe/test/ObjectPage";
+<% } -%>
+<% if (pages.some(p => p.template === 'ListReport' || p.template === 'ObjectPage')) { -%>
+import type { actions as TemplatePageActions, assertions as TemplatePageAssertions } from "sap/fe/test/TemplatePage";
+<% } -%>
+import type Shell from "sap/fe/test/Shell";
+import type BaseArrangements from "sap/fe/test/BaseArrangements";
+<% pages.filter((p) => p.template === 'ListReport' || p.template === 'ObjectPage').forEach(function(page) { -%>
+import type { actions as <%- page.targetKey %>CustomActions, assertions as <%- page.targetKey %>CustomAssertions } from "../pages/<%- page.targetKey %>";
+<% }); -%>
+
+export type Given = Opa5 & BaseArrangements & {
+    iTearDownMyApp: () => Given;
+    iStartMyApp: (sAppHash?: string, mInUrlParameters?: object) => Given;
+    and: Given;
+};
+
+export type When = Opa5 & BaseArrangements & {
+<% pages.forEach(function(page) { -%>
+<% if (page.template === 'ListReport') { -%>
+    onThe<%- page.targetKey %>: Opa5 & ListReportActions & TemplatePageActions & typeof <%- page.targetKey %>CustomActions;
+<% } else if (page.template === 'ObjectPage') { -%>
+    onThe<%- page.targetKey %>: Opa5 & ObjectPageActions & TemplatePageActions & typeof <%- page.targetKey %>CustomActions;
+<% } -%>
+<% }); -%>
+    onTheShell: Shell;
+};
+
+export type Then = Opa5 & BaseArrangements & {
+<% pages.forEach(function(page) { -%>
+<% if (page.template === 'ListReport') { -%>
+    onThe<%- page.targetKey %>: Opa5 & ListReportAssertions & TemplatePageAssertions & typeof <%- page.targetKey %>CustomAssertions;
+<% } else if (page.template === 'ObjectPage') { -%>
+    onThe<%- page.targetKey %>: Opa5 & ObjectPageAssertions & TemplatePageAssertions & typeof <%- page.targetKey %>CustomAssertions;
+<% } -%>
+<% }); -%>
+    onTheShell: Shell;
+};