@ui5/task-adaptation 1.6.5-rc.3 → 1.6.5

package/dist/adapters/commands/fetchPreviewResourcesCommand.js

@@ -0,0 +1,102 @@
+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")) {
+                content = this.modifyRoutes(content, libraryName, libId);
+            }
+            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>;
+}

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,51 @@
+import { PostCommand } from "./command.js";
+import { getLogger } from "@ui5/logger";
+import { merge, XSAPP_JSON_FILENAME } from "../../util/cf/xsAppJsonUtil.js";
+import ResourceUtil from "../../util/resourceUtil.js";
+import { REUSE_DIR } from "../../model/configuration.js";
+import XsAppJsonEnhanceRoutesCommand from "./xsAppJsonEnhanceRoutesCommand.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);
+        new XsAppJsonEnhanceRoutesCommand(this.serviceCredentialsPromise).execute(mergedFiles);
+        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)) {
+                    mergedXsAppJson = mergedXsAppJson ? merge([content, mergedXsAppJson]) : content;
+                }
+                mergedFiles.set(filename, content);
+            }
+        }
+        if (mergedXsAppJson) {
+            mergedFiles.set(XSAPP_JSON_FILENAME, mergedXsAppJson);
+        }
+        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/{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 { 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;
@@ -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