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

package/dist/adapters/commands/omitDeletedResourcesCommand.js

@@ -0,0 +1,31 @@
+import ResourceUtil from "../../util/resourceUtil.js";
+import { PostCommand } from "./command.js";
+export default class OmitDeletedResourcesCommand extends PostCommand {
+    taskUtil;
+    movedFiles;
+    resources;
+    projectNamespace;
+    constructor(taskUtil, movedFiles, resources = [], projectNamespace) {
+        super();
+        this.taskUtil = taskUtil;
+        this.movedFiles = movedFiles;
+        this.resources = resources;
+        this.projectNamespace = projectNamespace;
+    }
+    async execute(files) {
+        for (const resource of this.resources) {
+            const relativePath = ResourceUtil.relativeToRoot(resource.getPath(), this.projectNamespace);
+            if (!files.has(relativePath)) {
+                this.taskUtil.setTag(resource, this.taskUtil.STANDARD_TAGS.OmitFromBuildResult, true);
+                const newPath = this.movedFiles.get(relativePath);
+                if (newPath) {
+                    const renamedContent = files.get(newPath);
+                    if (renamedContent) {
+                        resource.setString(renamedContent);
+                    }
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=omitDeletedResourcesCommand.js.map

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

@@ -0,0 +1,9 @@
+import { PostCommand } from "./command.js";
+import { FetchFilesPromise, ServiceCredentials } from "../../model/types.js";
+export default class ProcessPreviewResourcesCommand extends PostCommand {
+    private serviceCredentialsPromise;
+    private previewPromise;
+    constructor(serviceCredentialsPromise: Promise<ServiceCredentials | undefined>, previewPromise: Promise<FetchFilesPromise | undefined>);
+    execute(files: Map<string, string>): Promise<void>;
+    private collectReuseLibFiles;
+}

package/dist/adapters/commands/processPreviewResourcesCommand.js

@@ -0,0 +1,55 @@
+import { PostCommand } from "./command.js";
+import { getLogger } from "@ui5/logger";
+import { fetchCredentialsAndEnhanceRoutes, merge, XSAPP_JSON_FILENAME } from "../../util/cf/xsAppJsonUtil.js";
+import ResourceUtil from "../../util/resourceUtil.js";
+import { REUSE_DIR } from "../../model/configuration.js";
+const log = getLogger("@ui5/task-adaptation::ProcessPreviewResourcesCommand");
+export default class ProcessPreviewResourcesCommand extends PostCommand {
+    serviceCredentialsPromise;
+    previewPromise;
+    constructor(serviceCredentialsPromise, previewPromise) {
+        super();
+        this.serviceCredentialsPromise = serviceCredentialsPromise;
+        this.previewPromise = previewPromise;
+    }
+    async execute(files) {
+        log.verbose(`Downloading reuse libraries to reuse folder`);
+        const baseAppXsAppJson = files.get(XSAPP_JSON_FILENAME);
+        const mergedFiles = await this.collectReuseLibFiles(await this.previewPromise, baseAppXsAppJson);
+        const xsAppJson = mergedFiles.get(XSAPP_JSON_FILENAME);
+        if (xsAppJson) {
+            const enhanced = await fetchCredentialsAndEnhanceRoutes(xsAppJson.toString("utf8"), this.serviceCredentialsPromise);
+            mergedFiles.set(XSAPP_JSON_FILENAME, Buffer.from(enhanced, "utf8"));
+        }
+        if (mergedFiles.size === 0) {
+            return;
+        }
+        await ResourceUtil.writeInProject(REUSE_DIR, mergedFiles);
+    }
+    async collectReuseLibFiles(fetchLibsPromises, mergedXsAppJson) {
+        const mergedFiles = new Map();
+        if (!fetchLibsPromises) {
+            log.verbose("No reuse libraries defined in ui5AppInfo.json for preview");
+            return mergedFiles;
+        }
+        for (const [libName, libFilesPromise] of fetchLibsPromises) {
+            const libFiles = await libFilesPromise;
+            if (!libFiles || libFiles.size === 0) {
+                log.warn(`No files found in reuse library ${libName} for preview`);
+                continue;
+            }
+            for (const [filename, content] of libFiles) {
+                if (filename.endsWith(XSAPP_JSON_FILENAME)) {
+                    const xsAppText = content.toString("utf8");
+                    mergedXsAppJson = mergedXsAppJson ? merge([xsAppText, mergedXsAppJson]) : xsAppText;
+                }
+                mergedFiles.set(filename, content);
+            }
+        }
+        if (mergedXsAppJson) {
+            mergedFiles.set(XSAPP_JSON_FILENAME, Buffer.from(mergedXsAppJson, "utf8"));
+        }
+        return mergedFiles;
+    }
+}
+//# sourceMappingURL=processPreviewResourcesCommand.js.map

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

@@ -0,0 +1,20 @@
+import { PostCommand } from "./command.js";
+export default class RenameFilesCommand extends PostCommand {
+    private references;
+    constructor(references: Map<string, string>);
+    execute(files: Map<string, string>): Promise<void>;
+    /**
+         * 1p. i18n.properties are not renamed and property keys are ignored during
+         * the renaming across the files.
+         * @param files - all files both base and appVariants
+         * @param references - Reference maps of the app variant
+         * @returns A map of renamed files
+         */
+    rename(files: Map<string, string>, references: Map<string, string>): void;
+    private getManifestSAPUI5DependencyIds;
+    private getI18nPropertyKeys;
+}
+/**
+ * We might rename appVariantIdHierarchy and dependencies, so we restore them after the renaming.
+ */
+export declare function restoreWhatShouldntBeRenamed(): (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) => void;

package/dist/{util/filesUtil.js → adapters/commands/renameFilesCommand.js}

@@ -4,58 +4,47 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { renameMap } from "./renamingUtil.js";
-import ManifestRenamingHandler from "./renamingHandlers/manifestRenamingHandler.js";
-export default class FilesUtil {
-    static filter(files) {
-        const shouldIgnore = (filename, content) => {
-            const IGNORE_FILES = ["manifest.appdescr_variant"];
-            if (filename.endsWith(".change")) {
-                return JSON.parse(content).changeType?.startsWith("appdescr_"); // validate JSON
-            }
-            return IGNORE_FILES.includes(filename);
-        };
-        const result = new Map();
-        files.forEach((content, filename) => {
-            if (!shouldIgnore(filename, content)) {
-                result.set(filename, content);
-            }
-        });
-        return result;
+import ManifestRenamingHandler from "../../util/renamingHandlers/manifestRenamingHandler.js";
+import { renameMap } from "../../util/renamingUtil.js";
+import { PostCommand } from "./command.js";
+export default class RenameFilesCommand extends PostCommand {
+    references;
+    constructor(references) {
+        super();
+        this.references = references;
     }
-    static sortByTimeStamp(a, b) {
-        if (a.creation < b.creation)
-            return -1;
-        if (a.creation > b.creation)
-            return 1;
-        return 0;
+    async execute(files) {
+        this.rename(files, this.references);
     }
     /**
-     * 1p. i18n.properties are not renamed and property keys are ignored during
-     * the renaming across the files.
-     * @param files - all files both base and appVariants
-     * @param references - Reference maps of the app variant
-     * @returns A map of renamed files
-     */
-    static rename(files, references) {
+         * 1p. i18n.properties are not renamed and property keys are ignored during
+         * the renaming across the files.
+         * @param files - all files both base and appVariants
+         * @param references - Reference maps of the app variant
+         * @returns A map of renamed files
+         */
+    rename(files, references) {
         const IGNORE_EXTENSIONS = [".properties"];
         const ignoreInString = [
             ...this.getI18nPropertyKeys(files),
             ...this.getManifestSAPUI5DependencyIds(files)
         ];
-        return new Map(Array.from(files, ([filename, content]) => {
+        const updates = new Map();
+        for (const [filename, content] of files) {
             if (!IGNORE_EXTENSIONS.some(ext => filename.endsWith(ext))) {
                 // 5p. We pass replacements as ignores since we don't want to
                 // rename them again. E.g. we replace app.id with
                 // customer.app.id, but if we found customer.app.id somewhere,
                 // because we applied changes or something, we don't want to
                 // rename it again to customer.customer.app.id.
-                content = renameMap(content, references, [...references.values(), ...ignoreInString]);
+                updates.set(filename, renameMap(content, references, [...references.values(), ...ignoreInString]));
             }
-            return [filename, content];
-        }));
+        }
+        for (const [filename, content] of updates) {
+            files.set(filename, content);
+        }
     }
-    static getManifestSAPUI5DependencyIds(files) {
+    getManifestSAPUI5DependencyIds(files) {
         const manifestFile = files.get("manifest.json");
         if (manifestFile) {
             const manifest = JSON.parse(manifestFile);
@@ -68,7 +57,7 @@ export default class FilesUtil {
         }
         return [];
     }
-    static getI18nPropertyKeys(files) {
+    getI18nPropertyKeys(files) {
         const keys = new Set();
         files.forEach((content, filename) => {
             if (filename.endsWith(".properties")) {
@@ -86,7 +75,7 @@ export default class FilesUtil {
 }
 __decorate([
     restoreWhatShouldntBeRenamed()
-], FilesUtil, "rename", null);
+], RenameFilesCommand.prototype, "rename", null);
 /**
  * We might rename appVariantIdHierarchy and dependencies, so we restore them after the renaming.
  */
@@ -95,12 +84,14 @@ export function restoreWhatShouldntBeRenamed() {
         const handlers = [new ManifestRenamingHandler()];
         const originalValue = descriptor.value;
         descriptor.value = function (...args) {
-            handlers.forEach(handler => handler.before(args[0]));
-            const renamedFiles = originalValue.apply(this, args);
-            handlers.forEach(handler => handler.after(renamedFiles));
-            return renamedFiles;
+            const files = args[0];
+            const references = args[1];
+            handlers.forEach(handler => handler.before(files));
+            originalValue.apply(this, [files, references]);
+            handlers.forEach(handler => handler.after(files));
+            return files;
         };
     };
 }
 ;
-//# sourceMappingURL=filesUtil.js.map
+//# sourceMappingURL=renameFilesCommand.js.map

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

@@ -0,0 +1,7 @@
+import { PostCommand } from "./command.js";
+export default class WriteResourcesCommand extends PostCommand {
+    private workspace;
+    private projectNamespace;
+    constructor(workspace: any, projectNamespace: string);
+    execute(files: Map<string, string>): Promise<void>;
+}

package/dist/adapters/commands/writeResourcesCommand.js

@@ -0,0 +1,20 @@
+import ResourceUtil from "../../util/resourceUtil.js";
+import { PostCommand } from "./command.js";
+export default class WriteResourcesCommand extends PostCommand {
+    workspace;
+    projectNamespace;
+    constructor(workspace, projectNamespace) {
+        super();
+        this.workspace = workspace;
+        this.projectNamespace = projectNamespace;
+    }
+    async execute(files) {
+        const writePromises = new Array();
+        files.forEach((content, filename) => {
+            const resource = ResourceUtil.createResource(filename, this.projectNamespace, content);
+            writePromises.push(this.workspace.write(resource));
+        });
+        await Promise.all(writePromises);
+    }
+}
+//# sourceMappingURL=writeResourcesCommand.js.map

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

@@ -1,7 +1,7 @@
-import { IConfiguration } from "../../model/types.js";
+import { ServiceCredentials } from "../../model/types.js";
 import { PostCommand } from "./command.js";
 export default class XsAppJsonEnhanceRoutesCommand extends PostCommand {
-    private configuration;
-    constructor(configuration: IConfiguration);
+    private serviceCredentialsPromise;
+    constructor(serviceCredentialsPromise: Promise<ServiceCredentials | undefined>);
     execute(files: Map<string, string>): Promise<void>;
 }

package/dist/adapters/commands/xsAppJsonEnhanceRoutesCommand.js

@@ -1,15 +1,15 @@
 import { fetchCredentialsAndEnhanceRoutes } from "../../util/cf/xsAppJsonUtil.js";
 import { PostCommand } from "./command.js";
 export default class XsAppJsonEnhanceRoutesCommand extends PostCommand {
-    configuration;
-    constructor(configuration) {
+    serviceCredentialsPromise;
+    constructor(serviceCredentialsPromise) {
         super();
-        this.configuration = configuration;
+        this.serviceCredentialsPromise = serviceCredentialsPromise;
     }
     async execute(files) {
         let xsAppJson = files.get("xs-app.json");
         if (xsAppJson) {
-            xsAppJson = await fetchCredentialsAndEnhanceRoutes(xsAppJson, this.configuration);
+            xsAppJson = await fetchCredentialsAndEnhanceRoutes(xsAppJson, this.serviceCredentialsPromise);
             files.set("xs-app.json", xsAppJson);
         }
     }

package/dist/adapters/previewAdapter.d.ts

@@ -1,12 +1,18 @@
-import AppVariant from "../appVariantManager.js";
-import BaseApp from "../baseAppManager.js";
+import AppVariant from "../appVariant.js";
+import BaseApp from "../baseApp.js";
 import { IConfiguration } from "../model/configuration.js";
+import { UI5BuilderTools } from "../model/types.js";
+import IRepository from "../repositories/repository.js";
 import { IAdapter } from "./adapter.js";
-import { AdaptCommandChain, MergeCommandChain, PostCommandChain } from "./commands/command.js";
+import CFAdapter from "./cfAdapter.js";
+import { AdaptCommandChain, PostCommandChain, SetupCommandChain } from "./commands/command.js";
 export default class PreviewAdapter implements IAdapter {
+    private configuration;
     private cfAdapter;
-    constructor(configuration: IConfiguration);
+    private fetchPreviewResourcesCommand;
+    private fetchEndpointsCommand;
+    constructor(configuration: IConfiguration, cfAdapter?: CFAdapter);
+    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/previewAdapter.js

@@ -1,17 +1,38 @@
+import { dependsOn, getCommonPostCommands } from "./adapter.js";
 import CFAdapter from "./cfAdapter.js";
+import { PostCommandChain, SetupCommandChain } from "./commands/command.js";
+import FetchEndpointsCommand from "./commands/fetchEndpointsCommand.js";
+import FetchPreviewResourcesCommand from "./commands/fetchPreviewResourcesCommand.js";
+import ProcessPreviewResourcesCommand from "./commands/processPreviewResourcesCommand.js";
+import XsAppJsonEnhanceRoutesCommand from "./commands/xsAppJsonEnhanceRoutesCommand.js";
 export default class PreviewAdapter {
+    configuration;
     cfAdapter;
-    constructor(configuration) {
-        this.cfAdapter = new CFAdapter(configuration);
+    fetchPreviewResourcesCommand = null;
+    fetchEndpointsCommand = null;
+    constructor(configuration, cfAdapter) {
+        this.configuration = configuration;
+        this.cfAdapter = cfAdapter ?? new CFAdapter(configuration);
+    }
+    createSetupCommandChain(appId, repository) {
+        this.fetchPreviewResourcesCommand = new FetchPreviewResourcesCommand(appId, repository);
+        this.fetchEndpointsCommand = new FetchEndpointsCommand(this.configuration);
+        return new SetupCommandChain([
+            this.fetchPreviewResourcesCommand,
+            this.fetchEndpointsCommand
+        ]);
     }
     createAdaptCommandChain(baseApp, appVariant) {
         return this.cfAdapter.createAdaptCommandChain(baseApp, appVariant);
     }
-    createMergeCommandChain(baseApp, appVariant) {
-        return this.cfAdapter.createMergeCommandChain(baseApp, appVariant);
-    }
-    createPostCommandChain() {
-        return this.cfAdapter.createPostCommandChain();
+    createPostCommandChain(references, adaptationProject, ui5BuilderTools) {
+        const serviceCredentialsPromise = dependsOn(this.fetchEndpointsCommand);
+        const previewPromise = dependsOn(this.fetchPreviewResourcesCommand);
+        return new PostCommandChain([
+            new ProcessPreviewResourcesCommand(serviceCredentialsPromise, previewPromise),
+            new XsAppJsonEnhanceRoutesCommand(serviceCredentialsPromise),
+            ...getCommonPostCommands(references, adaptationProject, ui5BuilderTools)
+        ]);
     }
 }
 //# sourceMappingURL=previewAdapter.js.map

package/dist/annotations/abapAnnotationManager.js

@@ -22,7 +22,7 @@ export default class AbapAnnotationManager {
         const i18nManager = new I18nManager(modelName, appVariantId, languages);
         const serviceRequestor = new ServiceRequestor(this.configuration, this.repository);
         const dataSourceManager = new DataSourceManager();
-        dataSourceManager.addDataSources(baseAppManifest["sap.app"]?.dataSources);
+        await dataSourceManager.addDataSources(baseAppManifest["sap.app"]?.dataSources);
         const annotationFiles = await dataSourceManager.createAnnotationFiles(languages, i18nManager, serviceRequestor);
         const i18nFiles = i18nManager.createFiles(i18nPathName);
         if (i18nManager.hasTranslations()) {

package/dist/annotations/dataSource/dataSourceManager.d.ts

@@ -3,10 +3,11 @@ import Language from "../../model/language.js";
 import ServiceRequestor from "../serviceRequestor.js";
 export default class DataSourceManager {
     private dataSources;
+    private shouldDownload;
     /**
      * Parses dataSources from manifest.json.
      * @param dataSourcesJson manifest.json/sap.app/dataSources node
      */
-    addDataSources(dataSourcesJson: any): void;
+    addDataSources(dataSourcesJson: any): Promise<void>;
     createAnnotationFiles(languages: Language[], i18nManager: I18nManager, serviceRequestor: ServiceRequestor): Promise<Map<string, string>>;
 }

package/dist/annotations/dataSource/dataSourceManager.js

@@ -1,20 +1,28 @@
-import DataSourceOData from "./dataSourceOData.js";
 import DataSourceODataAnnotation from "./dataSourceODataAnnotation.js";
 import path from "path/posix";
 export default class DataSourceManager {
     dataSources = new Array();
+    shouldDownload(dataSource, type) {
+        // is remote service, not local file
+        return dataSource.uri?.startsWith("/") &&
+            // no local metadata file and wasn't downloaded yet
+            !dataSource.settings?.ignoreAnnotationsFromMetadata &&
+            dataSource.type === type;
+    }
     /**
      * Parses dataSources from manifest.json.
      * @param dataSourcesJson manifest.json/sap.app/dataSources node
      */
-    addDataSources(dataSourcesJson) {
+    async addDataSources(dataSourcesJson) {
         if (!dataSourcesJson) {
             return;
         }
         const odataAnnotationMap = new Map();
+        const dataSourceODataEntries = Object.entries(dataSourcesJson).filter(([, dataSource]) => dataSource.uri?.startsWith("/") && dataSource.type === "OData");
+        const { default: DataSourceOData } = await import("./dataSourceOData.js");
         // Loop over OData first to collect linked annotation names
-        for (const [name, dataSource] of Object.entries(dataSourcesJson)) {
-            if (dataSource.uri?.startsWith("/") && dataSource.type === "OData") {
+        for (const [name, dataSource] of dataSourceODataEntries) {
+            if (this.shouldDownload(dataSource, "OData")) {
                 const uri = path.normalize(dataSource.uri + "/$metadata");
                 const odata = new DataSourceOData(name, uri, dataSource);
                 odata.getAnnotations().forEach(annotation => odataAnnotationMap.set(annotation, uri));
@@ -23,10 +31,11 @@ export default class DataSourceManager {
         }
         // If ODataAnnotation is in OData annotations, pass metadata url to it
         for (const [name, dataSource] of Object.entries(dataSourcesJson)) {
-            const uri = dataSource.uri;
             const metadataUrl = odataAnnotationMap.get(name);
-            if (uri?.startsWith("/") && dataSource.type === "ODataAnnotation") {
-                this.dataSources.push(new DataSourceODataAnnotation(name, uri, dataSource, metadataUrl));
+            if (this.shouldDownload(dataSource, "ODataAnnotation")) {
+                const uri = dataSource.uri;
+                const odata = new DataSourceODataAnnotation(name, uri, dataSource, metadataUrl);
+                this.dataSources.push(odata);
             }
         }
         for (const dataSource of this.dataSources) {

package/dist/{appVariantManager.d.ts → appVariant.d.ts}

@@ -1,5 +1,4 @@
 import { IChange } from "./model/types.js";
-import TaskUtil from "@ui5/project/build/helpers/TaskUtil";
 export default class AppVariant {
     readonly files: ReadonlyMap<string, string>;
     readonly resources?: ReadonlyArray<Resource>;
@@ -8,7 +7,7 @@ export default class AppVariant {
     readonly layer: any;
     readonly content: any;
     prefix: string;
-    private movedFiles;
+    movedFiles: Map<string, string>;
     private renaming;
     static fromWorkspace(workspace: IWorkspace, projectNamespace: string): Promise<AppVariant>;
     static fromFiles(files: ReadonlyMap<string, string>): AppVariant;
@@ -20,13 +19,7 @@ export default class AppVariant {
      */
     getRenamingForMovedFiles(): Map<string, string>;
     getProcessedManifestChanges(): IChange[];
+    private sortByTimeStamp;
     private validateManifest;
     private updateRelativePaths;
-    /**
-     * 3p. We not only omit files, which were moved or deleted from the resulted
-     * file set, but also update existing adaptation project resources with
-     * renamed content, otherwise flexibility-bundle will contain not renamed
-     * content of files.
-     */
-    omitDeletedResources(files: ReadonlyMap<string, string>, projectNamespace: string, taskUtil: TaskUtil): void;
 }

package/dist/{appVariantManager.js → appVariant.js}

@@ -1,8 +1,9 @@
 import { dotToUnderscore, isManifestChange } from "./util/commonUtil.js";
-import FilesUtil from "./util/filesUtil.js";
-import ResourceUtil from "./util/resourceUtil.js";
+import ResourceUtil, { TEXT_EXTENSIONS } from "./util/resourceUtil.js";
 import { posix as path } from "path";
 import { moveFile, moveFiles } from "./util/movingHandler/changeFileMoveHandler.js";
+import RenameFilesCommand from "./adapters/commands/renameFilesCommand.js";
+import { validateAppId } from "./util/validator/validator.js";
 const CHANGES_EXT = ".change";
 export default class AppVariant {
     files;
@@ -15,7 +16,7 @@ export default class AppVariant {
     movedFiles = new Map();
     renaming = new Map();
     static async fromWorkspace(workspace, projectNamespace) {
-        const EXTENSIONS_TO_PROCESS = "js,json,xml,html,properties,change,appdescr_variant,ctrl_variant,ctrl_variant_change,ctrl_variant_management_change,variant,fioriversion,codeChange,xmlViewChange,context";
+        const EXTENSIONS_TO_PROCESS = Array.from(TEXT_EXTENSIONS).join(",");
         const resources = await workspace.byGlob(`/**/*.{${EXTENSIONS_TO_PROCESS}}`);
         const files = await ResourceUtil.toFileMap(resources, projectNamespace);
         return new AppVariant(files, resources);
@@ -34,6 +35,7 @@ export default class AppVariant {
         const { reference, id, layer, content } = JSON.parse(manifestString);
         this.reference = reference;
         this.id = id;
+        validateAppId(id);
         this.layer = layer;
         this.content = content;
         // Prefix is a subfolder for the app variant to store js, fragments,
@@ -45,7 +47,8 @@ export default class AppVariant {
         const { files, renamingPaths } = moveFiles(this.files, this.prefix, this.id);
         // Directly rename files that with new paths, this ensures no conflict in further renaming
         // In later remaming it's not possible to find correct prefix of moved files
-        return FilesUtil.rename(files, renamingPaths);
+        new RenameFilesCommand(renamingPaths).execute(files);
+        return files;
     }
     ;
     /**
@@ -75,13 +78,20 @@ export default class AppVariant {
                 }
             }
         });
-        changeFileChanges.sort(FilesUtil.sortByTimeStamp);
+        changeFileChanges.sort(this.sortByTimeStamp);
         manifestChanges.push(...changeFileChanges);
         if (this.layer) {
             manifestChanges.forEach(change => change.layer = this.layer ?? change.layer);
         }
         return manifestChanges;
     }
+    sortByTimeStamp(a, b) {
+        if (a.creation < b.creation)
+            return -1;
+        if (a.creation > b.creation)
+            return 1;
+        return 0;
+    }
     validateManifest(manifest) {
         if (!manifest) {
             throw new Error("Adaptation project should contain manifest.appdescr_variant");
@@ -98,27 +108,5 @@ export default class AppVariant {
             }
         }
     }
-    /**
-     * 3p. We not only omit files, which were moved or deleted from the resulted
-     * file set, but also update existing adaptation project resources with
-     * renamed content, otherwise flexibility-bundle will contain not renamed
-     * content of files.
-     */
-    omitDeletedResources(files, projectNamespace, taskUtil) {
-        if (!this.resources) {
-            return;
-        }
-        for (const resource of this.resources) {
-            const relativePath = ResourceUtil.relativeToRoot(resource.getPath(), projectNamespace);
-            if (!files.has(relativePath)) {
-                taskUtil.setTag(resource, taskUtil.STANDARD_TAGS.OmitFromBuildResult, true);
-                if (this.movedFiles.has(relativePath)) {
-                    const newPath = this.movedFiles.get(relativePath);
-                    const renamedContent = files.get(newPath);
-                    resource.setString(renamedContent);
-                }
-            }
-        }
-    }
 }
-//# sourceMappingURL=appVariantManager.js.map
+//# sourceMappingURL=appVariant.js.map

package/dist/{baseAppManager.js → baseApp.js}

@@ -1,4 +1,5 @@
 import { trimExtension } from "./util/commonUtil.js";
+import { validateAppId } from "./util/validator/validator.js";
 const IGNORE_FILES = [
     "manifest-bundle.zip",
     "Component-preload.js",
@@ -72,22 +73,15 @@ export default class BaseApp {
         }
         return "i18n/i18n";
     }
-    VALIDATION_RULES = new Map([["sap.app/id", (value) => {
-                if (!value.includes(".")) {
-                    // https://help.sap.com/docs/bas/developing-sap-fiori-app-in-sap-business-application-studio/releasing-sap-fiori-application-to-be-extensible-in-adaptation-projects-on-sap-s-4hana-cloud
-                    // In the manifest.json file, make sure that the attribute
-                    // sap.app/id has at least 2 segments.
-                    throw new Error(`The original application id '${value}' should consist of multiple segments split by dot, e.g.: original.id`);
-                }
-            }]]);
+    VALIDATION_RULES = new Map([["sap.app/id", validateAppId]]);
     validateProperty(value, property) {
         if (!value) {
             throw new Error(`Original application manifest should have ${property}`);
         }
-        let validatationRule = this.VALIDATION_RULES.get(property);
-        if (validatationRule) {
-            validatationRule(value);
+        let validationRule = this.VALIDATION_RULES.get(property);
+        if (validationRule) {
+            validationRule(value);
         }
     }
 }
-//# sourceMappingURL=baseAppManager.js.map
+//# sourceMappingURL=baseApp.js.map