@ui5/task-adaptation 1.6.5-rc.2 → 1.6.5-rc.4

package/CHANGELOG.md

@@ -2,7 +2,16 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
-A list of unreleased changes can be found [here](https://github.com/SAP/ui5-task-adaptation/compare/v1.6.5-rc.2...HEAD).
+A list of unreleased changes can be found [here](https://github.com/SAP/ui5-task-adaptation/compare/v1.6.5-rc.4...HEAD).
+
+<a name="v1.6.5-rc.4"></a>
+## [v1.6.5-rc.4] - 2026-06-23
+
+<a name="v1.6.5-rc.3"></a>
+## [v1.6.5-rc.3] - 2026-04-27
+### Reverts
+- Release 1.6.5-rc.0
+
 
 <a name="v1.6.5-rc.2"></a>
 ## [v1.6.5-rc.2] - 2026-04-14
@@ -188,6 +197,8 @@ A list of unreleased changes can be found [here](https://github.com/SAP/ui5-task
 <a name="v1.0.0"></a>
 ## v1.0.0 - 2020-12-09
 
+[v1.6.5-rc.4]: https://github.com/SAP/ui5-task-adaptation/compare/v1.6.5-rc.3...v1.6.5-rc.4
+[v1.6.5-rc.3]: https://github.com/SAP/ui5-task-adaptation/compare/v1.6.5-rc.2...v1.6.5-rc.3
 [v1.6.5-rc.2]: https://github.com/SAP/ui5-task-adaptation/compare/v1.6.5-rc.1...v1.6.5-rc.2
 [v1.6.5-rc.1]: https://github.com/SAP/ui5-task-adaptation/compare/v1.6.4-rc.3...v1.6.5-rc.1
 [v1.6.4-rc.3]: https://github.com/SAP/ui5-task-adaptation/compare/v1.6.4-rc.2...v1.6.4-rc.3

package/REUSE.toml

@@ -7,4 +7,4 @@ SPDX-PackageDownloadLocation = "https://github.com/SAP/ui5-task-adaptation"
 path = "**.**"
 precedence = "aggregate"
 SPDX-FileCopyrightText = "2009-2025 SAP SE or an SAP affiliate company"
-SPDX-License-Identifier = "Apache-2.0"
+SPDX-License-Identifier = "Apache-2.0"

package/dist/adapters/abapAdapter.d.ts

@@ -1,12 +1,14 @@
 import { IAdapter } from "./adapter.js";
-import { AdaptCommandChain, MergeCommandChain, PostCommandChain } from "./commands/command.js";
-import BaseApp from "../baseAppManager.js";
-import AppVariant from "../appVariantManager.js";
+import { AdaptCommandChain, PostCommandChain, SetupCommandChain } from "./commands/command.js";
+import BaseApp from "../baseApp.js";
+import AppVariant from "../appVariant.js";
 import IAnnotationManager from "../annotations/annotationManager.js";
+import { UI5BuilderTools } from "../model/types.js";
+import IRepository from "../repositories/repository.js";
 export default class AbapAdapter implements IAdapter {
     private annotationManager;
     constructor(annotationManager: IAnnotationManager);
+    createSetupCommandChain(_appId: string, _repository: IRepository): SetupCommandChain;
     createAdaptCommandChain(baseApp: BaseApp, appVariant: AppVariant): AdaptCommandChain;
-    createMergeCommandChain(baseApp: BaseApp, appVariant: AppVariant): MergeCommandChain;
-    createPostCommandChain(): PostCommandChain;
+    createPostCommandChain(references: Map<string, string>, adaptationProject: AppVariant, ui5BuilderTools: UI5BuilderTools): PostCommandChain;
 }

package/dist/adapters/abapAdapter.js

@@ -1,5 +1,5 @@
-import { getCommonManifestUpdateCommands } from "./adapter.js";
-import { AdaptCommandChain, ManifestUpdateCommandChain, MergeCommandChain, PostCommandChain } from "./commands/command.js";
+import { getCommonManifestUpdateCommands, getCommonPostCommands } from "./adapter.js";
+import { AdaptCommandChain, ManifestUpdateCommandChain, PostCommandChain, SetupCommandChain } from "./commands/command.js";
 import DownloadAnnotationsCommand from "./commands/downloadAnnotationsCommand.js";
 import I18nPropertiesMergeCommand from "./commands/i18nPropertiesMergeCommand.js";
 export default class AbapAdapter {
@@ -7,28 +7,26 @@ export default class AbapAdapter {
     constructor(annotationManager) {
         this.annotationManager = annotationManager;
     }
+    createSetupCommandChain(_appId, _repository) {
+        return new SetupCommandChain([]);
+    }
     createAdaptCommandChain(baseApp, appVariant) {
         const appVariantIdHierarchyItem = {
             appVariantId: baseApp.id,
             version: baseApp.version,
             layer: "VENDOR"
         };
-        return new AdaptCommandChain(baseApp.files, [
+        const manifestChanges = appVariant.getProcessedManifestChanges();
+        return new AdaptCommandChain(baseApp.files, appVariant.getProcessedFiles(), [
             new ManifestUpdateCommandChain([
                 ...getCommonManifestUpdateCommands(baseApp, appVariant, appVariantIdHierarchyItem),
             ]),
             new DownloadAnnotationsCommand(appVariant.id, appVariant.prefix, this.annotationManager),
-        ]);
-    }
-    createMergeCommandChain(baseApp, appVariant) {
-        const manifestChanges = appVariant.getProcessedManifestChanges();
-        return new MergeCommandChain(appVariant.getProcessedFiles(), [
             new I18nPropertiesMergeCommand(baseApp.i18nPath, appVariant.prefix, manifestChanges),
         ]);
     }
-    createPostCommandChain() {
-        // No post commands needed for ABAP, return an empty chain
-        return new PostCommandChain([]);
+    createPostCommandChain(references, adaptationProject, ui5BuilderTools) {
+        return new PostCommandChain(getCommonPostCommands(references, adaptationProject, ui5BuilderTools));
     }
 }
 //# sourceMappingURL=abapAdapter.js.map

package/dist/adapters/adapter.d.ts

@@ -1,10 +1,14 @@
-import AppVariant from "../appVariantManager.js";
-import BaseApp from "../baseAppManager.js";
+import AppVariant from "../appVariant.js";
+import BaseApp from "../baseApp.js";
 import { IAppVariantIdHierarchyManifestItem } from "../model/appVariantIdHierarchyItem.js";
-import { AdaptCommandChain, ManifestUpdateCommand, MergeCommandChain, PostCommandChain } from "./commands/command.js";
+import { UI5BuilderTools } from "../model/types.js";
+import IRepository from "../repositories/repository.js";
+import { AdaptCommandChain, IPromiseCommand, ManifestUpdateCommand, PostCommand, PostCommandChain, SetupCommandChain } from "./commands/command.js";
 export interface IAdapter {
+    createSetupCommandChain(appId: string, repository: IRepository): SetupCommandChain;
     createAdaptCommandChain(baseApp: BaseApp, appVariant: AppVariant): AdaptCommandChain;
-    createMergeCommandChain(baseApp: BaseApp, appVariant: AppVariant): MergeCommandChain;
-    createPostCommandChain(): PostCommandChain;
+    createPostCommandChain(references: Map<string, string>, adaptationProject: AppVariant, ui5BuilderTools: UI5BuilderTools): PostCommandChain;
 }
 export declare function getCommonManifestUpdateCommands(baseApp: BaseApp, appVariant: AppVariant, appVariantIdHierarchyItem: IAppVariantIdHierarchyManifestItem): ManifestUpdateCommand[];
+export declare function getCommonPostCommands(references: Map<string, string>, adaptationProject: AppVariant, ui5BuilderTools: UI5BuilderTools): PostCommand[];
+export declare function dependsOn<T>(promise: IPromiseCommand<T> | null): Promise<T>;

package/dist/adapters/adapter.js

@@ -1,8 +1,12 @@
 import AddAppVariantIdHierarchyCommand from "./commands/addAppVariantIdHierarchyCommand.js";
 import ApplyDescriptorChangesCommand from "./commands/applyDescriptorChangesCommand.js";
+import FilterFilesCommand from "./commands/filterFilesCommand.js";
+import OmitDeletedResourcesCommand from "./commands/omitDeletedResourcesCommand.js";
+import RenameFilesCommand from "./commands/renameFilesCommand.js";
 import SetAppVariantIdCommand from "./commands/setAppVariantIdCommand.js";
 import UpdateCloudDevAdaptationCommand from "./commands/updateCloudDevAdaptationCommand.js";
 import UpdateComponentNameCommand from "./commands/updateComponentNameCommand.js";
+import WriteResourcesCommand from "./commands/writeResourcesCommand.js";
 export function getCommonManifestUpdateCommands(baseApp, appVariant, appVariantIdHierarchyItem) {
     const manifestChanges = appVariant.getProcessedManifestChanges();
     return [
@@ -13,4 +17,20 @@ export function getCommonManifestUpdateCommands(baseApp, appVariant, appVariantI
         new UpdateCloudDevAdaptationCommand(),
     ];
 }
+export function getCommonPostCommands(references, adaptationProject, ui5BuilderTools) {
+    const { movedFiles, resources } = adaptationProject;
+    const { workspace, taskUtil, projectNamespace } = ui5BuilderTools;
+    return [
+        new FilterFilesCommand(),
+        new RenameFilesCommand(references),
+        new OmitDeletedResourcesCommand(taskUtil, movedFiles, resources, projectNamespace),
+        new WriteResourcesCommand(workspace, projectNamespace),
+    ];
+}
+export function dependsOn(promise) {
+    if (!promise) {
+        throw new Error("Dependent command was not executed, promise is not available");
+    }
+    return promise.result;
+}
 //# sourceMappingURL=adapter.js.map

package/dist/adapters/cfAdapter.d.ts

@@ -1,12 +1,15 @@
 import { IConfiguration } from "../model/configuration.js";
 import { IAdapter } from "./adapter.js";
-import { AdaptCommandChain, MergeCommandChain, PostCommandChain } from "./commands/command.js";
-import BaseApp from "../baseAppManager.js";
-import AppVariant from "../appVariantManager.js";
+import { AdaptCommandChain, PostCommandChain, SetupCommandChain } from "./commands/command.js";
+import BaseApp from "../baseApp.js";
+import AppVariant from "../appVariant.js";
+import { UI5BuilderTools } from "../model/types.js";
+import IRepository from "../repositories/repository.js";
 export default class CFAdapter implements IAdapter {
     private configuration;
+    private fetchEndpointsCommand;
     constructor(configuration: IConfiguration);
+    createSetupCommandChain(_appId: string, _repository: IRepository): SetupCommandChain;
     createAdaptCommandChain(baseApp: BaseApp, appVariant: AppVariant): AdaptCommandChain;
-    createMergeCommandChain(baseApp: BaseApp, appVariant: AppVariant): MergeCommandChain;
-    createPostCommandChain(): PostCommandChain;
+    createPostCommandChain(references: Map<string, string>, adaptationProject: AppVariant, ui5BuilderTools: UI5BuilderTools): PostCommandChain;
 }

package/dist/adapters/cfAdapter.js

@@ -1,36 +1,42 @@
-import { getCommonManifestUpdateCommands } from "./adapter.js";
-import { AdaptCommandChain, ManifestUpdateCommandChain, MergeCommandChain, PostCommandChain } from "./commands/command.js";
+import { dependsOn, getCommonManifestUpdateCommands, getCommonPostCommands } from "./adapter.js";
+import { AdaptCommandChain, ManifestUpdateCommandChain, PostCommandChain, SetupCommandChain } from "./commands/command.js";
 import XsAppJsonEnhanceRoutesCommand from "./commands/xsAppJsonEnhanceRoutesCommand.js";
 import UpdateCloudPlatformCommand from "./commands/updateCloudPlatformCommand.js";
 import I18nPropertiesMergeCommand from "./commands/i18nPropertiesMergeCommand.js";
 import XsAppJsonMergeCommand from "./commands/xsAppJsonMergeCommand.js";
+import FetchEndpointsCommand from "./commands/fetchEndpointsCommand.js";
 export default class CFAdapter {
     configuration;
+    fetchEndpointsCommand = null;
     constructor(configuration) {
         this.configuration = configuration;
     }
+    createSetupCommandChain(_appId, _repository) {
+        this.fetchEndpointsCommand = new FetchEndpointsCommand(this.configuration);
+        return new SetupCommandChain([
+            this.fetchEndpointsCommand
+        ]);
+    }
     createAdaptCommandChain(baseApp, appVariant) {
         const appVariantIdHierarchyItem = {
             appVariantId: baseApp.id,
             version: baseApp.version
         };
-        return new AdaptCommandChain(baseApp.files, [
+        const manifestChanges = appVariant.getProcessedManifestChanges();
+        return new AdaptCommandChain(baseApp.files, appVariant.getProcessedFiles(), [
             new ManifestUpdateCommandChain([
                 ...getCommonManifestUpdateCommands(baseApp, appVariant, appVariantIdHierarchyItem),
                 new UpdateCloudPlatformCommand(this.configuration.sapCloudService),
             ]),
-        ]);
-    }
-    createMergeCommandChain(baseApp, appVariant) {
-        const manifestChanges = appVariant.getProcessedManifestChanges();
-        return new MergeCommandChain(appVariant.getProcessedFiles(), [
             new I18nPropertiesMergeCommand(baseApp.i18nPath, appVariant.prefix, manifestChanges),
             new XsAppJsonMergeCommand(),
         ]);
     }
-    createPostCommandChain() {
+    createPostCommandChain(references, adaptationProject, ui5BuilderTools) {
+        const serviceCredentialsPromise = dependsOn(this.fetchEndpointsCommand);
         return new PostCommandChain([
-            new XsAppJsonEnhanceRoutesCommand(this.configuration),
+            new XsAppJsonEnhanceRoutesCommand(serviceCredentialsPromise),
+            ...getCommonPostCommands(references, adaptationProject, ui5BuilderTools)
         ]);
     }
 }

package/dist/adapters/commands/command.d.ts

@@ -1,3 +1,18 @@
+export declare abstract class SetupCommand {
+    readonly commandType = "setup";
+    /**
+     * Executes the command
+     */
+    abstract execute(): Promise<void>;
+}
+export declare class SetupCommandChain {
+    private commands;
+    constructor(commands: SetupCommand[]);
+    /**
+     * Executes all commands in the chain
+     */
+    execute(): Promise<void>;
+}
 export declare abstract class AdaptCommand {
     readonly commandType = "adapt";
     abstract accept(filename: string): boolean;
@@ -8,15 +23,6 @@ export declare abstract class AdaptCommand {
      */
     abstract execute(files: Map<string, string>, filename: string): Promise<void>;
 }
-export declare class AdaptCommandChain {
-    private files;
-    private commands;
-    constructor(files: ReadonlyMap<string, string>, commands: AdaptCommand[]);
-    /**
-     * Executes all commands in the chain that accept the given filename
-     */
-    execute(): Promise<ReadonlyMap<string, string>>;
-}
 export declare abstract class MergeCommand {
     readonly commandType = "merge";
     abstract accept(filename: string): boolean;
@@ -28,20 +34,6 @@ export declare abstract class MergeCommand {
      */
     abstract execute(files: Map<string, string>, filename: string, appVariantContent: string): Promise<void>;
 }
-/**
- * CommandChain implements the Chain of Responsibility pattern
- * It manages a collection of commands and executes them in sequence
- */
-export declare class MergeCommandChain {
-    private appVariantFiles;
-    private commands;
-    constructor(appVariantFiles: ReadonlyMap<string, string>, commands?: MergeCommand[]);
-    /**
-     * Executes all commands in the chain that accept the given filename
-     * @param files - Map of all files being processed
-     */
-    execute(files: ReadonlyMap<string, string>): Promise<ReadonlyMap<string, string>>;
-}
 export declare abstract class ManifestUpdateCommand {
     readonly commandType = "manifestUpdate";
     /**
@@ -77,3 +69,14 @@ export declare class PostCommandChain {
      */
     execute(files: ReadonlyMap<string, string>): Promise<ReadonlyMap<string, string>>;
 }
+export declare class AdaptCommandChain {
+    private files;
+    private appVariantFiles;
+    private adaptCommands;
+    private mergeCommands;
+    constructor(files: ReadonlyMap<string, string>, appVariantFiles: ReadonlyMap<string, string>, commands: (AdaptCommand | MergeCommand)[]);
+    execute(): Promise<ReadonlyMap<string, string>>;
+}
+export interface IPromiseCommand<T> {
+    result: Promise<T>;
+}

package/dist/adapters/commands/command.js

@@ -1,62 +1,32 @@
-export class AdaptCommand {
-    commandType = "adapt";
+import { getLogger } from "@ui5/logger";
+const log = getLogger("@ui5/task-adaptation::CommandChain");
+export class SetupCommand {
+    commandType = "setup";
 }
-export class AdaptCommandChain {
-    files;
+export class SetupCommandChain {
     commands;
-    constructor(files, commands) {
-        this.files = files;
+    constructor(commands) {
         this.commands = commands;
     }
     /**
-     * Executes all commands in the chain that accept the given filename
+     * Executes all commands in the chain
      */
     async execute() {
-        const filesCopy = new Map(this.files);
-        for (const [filename] of filesCopy) {
-            for (const command of this.commands) {
-                if (command.accept(filename)) {
-                    await command.execute(filesCopy, filename);
-                }
-            }
+        const timings = [];
+        for (const command of this.commands) {
+            const start = performance.now();
+            await command.execute();
+            pushTiming(command, timings, start);
         }
-        return filesCopy;
+        logTimings(this, timings);
     }
 }
+export class AdaptCommand {
+    commandType = "adapt";
+}
 export class MergeCommand {
     commandType = "merge";
 }
-/**
- * CommandChain implements the Chain of Responsibility pattern
- * It manages a collection of commands and executes them in sequence
- */
-export class MergeCommandChain {
-    appVariantFiles;
-    commands;
-    constructor(appVariantFiles, commands = []) {
-        this.appVariantFiles = appVariantFiles;
-        this.commands = commands;
-    }
-    /**
-     * Executes all commands in the chain that accept the given filename
-     * @param files - Map of all files being processed
-     */
-    async execute(files) {
-        const filesCopy = new Map(files);
-        for (const [filename, appVariantContent] of this.appVariantFiles) {
-            const acceptedCommands = this.commands.filter(command => command.accept(filename));
-            if (acceptedCommands.length > 0) {
-                for (const command of acceptedCommands) {
-                    await command.execute(filesCopy, filename, appVariantContent);
-                }
-            }
-            else {
-                filesCopy.set(filename, appVariantContent);
-            }
-        }
-        return filesCopy;
-    }
-}
 export class ManifestUpdateCommand {
     commandType = "manifestUpdate";
 }
@@ -73,10 +43,14 @@ export class ManifestUpdateCommandChain extends AdaptCommand {
             throw new Error("Original application should have manifest.json in root folder");
         }
         const manifest = JSON.parse(manifestContent);
+        const timings = [];
         for (const command of this.commands) {
+            const start = performance.now();
             await command.execute(manifest);
+            pushTiming(command, timings, start);
         }
         files.set(filename, JSON.stringify(manifest));
+        logTimings(this, timings);
     }
 }
 export class PostCommand {
@@ -97,10 +71,63 @@ export class PostCommandChain {
      */
     async execute(files) {
         const filesCopy = new Map(files);
+        const timings = [];
         for (const command of this.commands) {
+            const start = performance.now();
             await command.execute(filesCopy);
+            pushTiming(command, timings, start);
+        }
+        logTimings(this, timings);
+        return filesCopy;
+    }
+}
+export class AdaptCommandChain {
+    files;
+    appVariantFiles;
+    adaptCommands;
+    mergeCommands;
+    constructor(files, appVariantFiles, commands) {
+        this.files = files;
+        this.appVariantFiles = appVariantFiles;
+        this.adaptCommands = commands.filter((c) => c.commandType === "adapt");
+        this.mergeCommands = commands.filter((c) => c.commandType === "merge");
+    }
+    async execute() {
+        const filesCopy = new Map(this.files);
+        const timings = [];
+        for (const command of this.adaptCommands) {
+            const start = performance.now();
+            for (const [filename] of filesCopy) {
+                if (command.accept(filename)) {
+                    await command.execute(filesCopy, filename);
+                }
+            }
+            pushTiming(command, timings, start);
         }
+        for (const command of this.mergeCommands) {
+            const start = performance.now();
+            for (const [filename, appVariantContent] of this.appVariantFiles) {
+                if (command.accept(filename)) {
+                    await command.execute(filesCopy, filename, appVariantContent);
+                }
+            }
+            pushTiming(command, timings, start);
+        }
+        for (const [filename, appVariantContent] of this.appVariantFiles) {
+            const accepted = this.mergeCommands.some(command => command.accept(filename));
+            if (!accepted) {
+                filesCopy.set(filename, appVariantContent);
+            }
+        }
+        logTimings(this, timings);
         return filesCopy;
     }
 }
+function logTimings(chain, timings) {
+    log.info(`${chain.constructor.name}:`);
+    timings.forEach(({ name, duration }) => log.info(`  ${name}: ${duration.toFixed(2)}ms`));
+}
+function pushTiming(command, timings, start) {
+    timings.push({ name: command.constructor.name, duration: performance.now() - start });
+}
 //# sourceMappingURL=command.js.map

package/dist/adapters/commands/fetchEndpointsCommand.d.ts

@@ -0,0 +1,9 @@
+import { IConfiguration } from "../../model/configuration.js";
+import { ServiceCredentials } from "../../model/types.js";
+import { IPromiseCommand, SetupCommand } from "./command.js";
+export default class FetchEndpointsCommand extends SetupCommand implements IPromiseCommand<ServiceCredentials | undefined> {
+    private configuration;
+    result: Promise<ServiceCredentials | undefined>;
+    constructor(configuration: IConfiguration);
+    execute(): Promise<void>;
+}

package/dist/adapters/commands/fetchEndpointsCommand.js

@@ -0,0 +1,21 @@
+import CFUtil from "../../util/cfUtil.js";
+import { validateObject } from "../../util/commonUtil.js";
+import { SetupCommand } from "./command.js";
+export default class FetchEndpointsCommand extends SetupCommand {
+    configuration;
+    result = Promise.resolve(undefined);
+    constructor(configuration) {
+        super();
+        this.configuration = configuration;
+    }
+    async execute() {
+        validateObject(this.configuration, ["serviceInstanceName"], "should be specified in ui5.yaml configuration");
+        const { serviceInstanceName, space } = this.configuration;
+        // Get valid service keys with proper endpoints structure
+        this.result = CFUtil.getOrCreateServiceKeyWithEndpoints(serviceInstanceName, space).catch(error => {
+            const errorText = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to get a service key with endpoints for service instance '${serviceInstanceName}' in space '${space}': ${errorText}`);
+        });
+    }
+}
+//# sourceMappingURL=fetchEndpointsCommand.js.map

package/dist/adapters/commands/fetchPreviewResourcesCommand.d.ts

@@ -0,0 +1,15 @@
+import { IPromiseCommand, SetupCommand } from "./command.js";
+import { FetchFilesPromise } from "../../model/types.js";
+import IRepository from "../../repositories/repository.js";
+export default class FetchPreviewResourcesCommand extends SetupCommand implements IPromiseCommand<FetchFilesPromise | undefined> {
+    private appId;
+    private repository;
+    result: Promise<FetchFilesPromise | undefined>;
+    constructor(appId: string, repository: IRepository);
+    execute(): Promise<void>;
+    private preparePreview;
+    private printMessages;
+    private preReadLibs;
+    private moveLibraryFiles;
+    private modifyRoutes;
+}

package/dist/adapters/commands/fetchPreviewResourcesCommand.js

@@ -0,0 +1,103 @@
+import FsUtil from "../../util/fsUtil.js";
+import { posix as path } from "path";
+import { SetupCommand } from "./command.js";
+import { getLogger } from "@ui5/logger";
+import { REUSE_DIR } from "../../model/configuration.js";
+const log = getLogger("@ui5/task-adaptation::FetchPreviewResourcesCommand");
+export default class FetchPreviewResourcesCommand extends SetupCommand {
+    appId;
+    repository;
+    result = Promise.resolve(undefined);
+    constructor(appId, repository) {
+        super();
+        this.appId = appId;
+        this.repository = repository;
+    }
+    async execute() {
+        this.result = this.preparePreview();
+    }
+    async preparePreview() {
+        let ui5AppInfo = "";
+        try {
+            ui5AppInfo = await FsUtil.readInProject("ui5AppInfo.json", "utf-8");
+        }
+        catch (error) {
+            throw new Error(`ui5AppInfo.json is missing in project root, cannot process preview resources: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // If no ui5AppInfo is provided, no preview processing is needed
+        if (!ui5AppInfo) {
+            log.verbose("No ui5AppInfo provided, skipping preview resources processing.");
+            return new Map();
+        }
+        const appInfo = JSON.parse(ui5AppInfo)[this.appId];
+        if (!appInfo) {
+            throw new Error(`No app info found for original app id '${this.appId}' in ui5AppInfo.json`);
+        }
+        this.printMessages(appInfo.messages);
+        const reuseLibs = appInfo.asyncHints.libs.filter(lib => lib.html5AppHostId && lib.html5AppName && lib.html5AppVersion);
+        if (reuseLibs.length > 0) {
+            return this.preReadLibs(reuseLibs, this.repository);
+        }
+        log.verbose("No reuse libraries defined in ui5AppInfo.json for preview");
+        return new Map();
+    }
+    printMessages(appInfoMessages) {
+        const logMap = {
+            Error: log.error,
+            Warning: log.warning,
+            Info: log.info,
+            debug: log.verbose
+        };
+        appInfoMessages.forEach((message) => {
+            const logger = logMap[message.severity] || log.info;
+            logger(`ui5AppInfo.json: ${message.severity} Message: ${message.message} (Error Code: ${message.errorCode})`);
+        });
+    }
+    preReadLibs(reuseLibs, repository) {
+        const promises = new Map();
+        reuseLibs.forEach(lib => {
+            log.info(`Downloading reuse library '${lib.html5AppName}' version '${lib.html5AppVersion}'`);
+            const resource = {
+                appName: lib.html5AppName,
+                appVersion: lib.html5AppVersion,
+                appHostId: lib.html5AppHostId,
+                cacheBusterToken: Promise.resolve(lib.html5CacheBusterToken)
+            };
+            const promise = repository
+                .fetch(resource)
+                .then((libFiles) => this.moveLibraryFiles(libFiles, lib.html5AppName, lib.name));
+            promises.set(lib.html5AppName, promise);
+        });
+        return promises;
+    }
+    moveLibraryFiles(inputFiles, libraryName, libId) {
+        const files = new Map();
+        inputFiles.forEach((content, filename) => {
+            const newFilename = path.join(libraryName, filename);
+            // Source path in xs-app.json needs to be adjusted to new location
+            if (filename.includes("xs-app.json")) {
+                const modified = this.modifyRoutes(content.toString("utf8"), libraryName, libId);
+                content = Buffer.from(modified, "utf8");
+            }
+            files.set(newFilename, content);
+        });
+        return files;
+    }
+    ;
+    modifyRoutes(xsAppJson, libName, libId) {
+        const xsApp = JSON.parse(xsAppJson);
+        xsApp.routes = xsApp.routes.map((route) => {
+            route.source = route.source.replace(new RegExp("^\\^\\/?(resources/)?"), `^/resources/${libId.replaceAll(".", "/")}/`);
+            if (route.service === "html5-apps-repo-rt") {
+                route = {
+                    source: route.source,
+                    target: route.target,
+                    localDir: [REUSE_DIR, libName].join("/")
+                };
+            }
+            return route;
+        });
+        return JSON.stringify(xsApp);
+    }
+}
+//# sourceMappingURL=fetchPreviewResourcesCommand.js.map

package/dist/adapters/commands/filterFilesCommand.d.ts

@@ -0,0 +1,4 @@
+import { PostCommand } from "./command.js";
+export default class FilterFilesCommand extends PostCommand {
+    execute(files: Map<string, string>): Promise<void>;
+}

package/dist/adapters/commands/filterFilesCommand.js

@@ -0,0 +1,22 @@
+import { PostCommand } from "./command.js";
+export default class FilterFilesCommand extends PostCommand {
+    async execute(files) {
+        const IGNORE_FILES = ["manifest.appdescr_variant"];
+        const shouldIgnore = (filename, content) => {
+            if (filename.endsWith(".change")) {
+                return JSON.parse(content).changeType?.startsWith("appdescr_"); // validate JSON
+            }
+            return IGNORE_FILES.includes(filename);
+        };
+        const toDelete = [];
+        for (const [filename, content] of files) {
+            if (shouldIgnore(filename, content)) {
+                toDelete.push(filename);
+            }
+        }
+        for (const filename of toDelete) {
+            files.delete(filename);
+        }
+    }
+}
+//# sourceMappingURL=filterFilesCommand.js.map

package/dist/adapters/commands/omitDeletedResourcesCommand.d.ts

@@ -0,0 +1,10 @@
+import TaskUtil from "@ui5/project/build/helpers/TaskUtil";
+import { PostCommand } from "./command.js";
+export default class OmitDeletedResourcesCommand extends PostCommand {
+    private taskUtil;
+    private movedFiles;
+    private resources;
+    private projectNamespace;
+    constructor(taskUtil: TaskUtil, movedFiles: Map<string, string>, resources: ReadonlyArray<Resource> | undefined, projectNamespace: string);
+    execute(files: Map<string, string>): Promise<void>;
+}