@ui5/task-adaptation 1.5.2 → 1.6.0

package/dist/cache/cacheHolder.d.ts

@@ -1,7 +1,7 @@
 export default class CacheHolder {
     private static TEMP_TASK_DIR;
     private static getTempDir;
-    static read(repoName: string, token: string): Map<string, string> | undefined;
+    static read(repoName: string, token: string): Promise<Map<string, string>>;
     static write(repoName: string, token: string, files: Map<string, string>): Promise<void>;
     private static isValid;
     /**

package/dist/cache/cacheHolder.js

@@ -1,21 +1,22 @@
 import * as fs from "fs";
 import * as fsPromises from "fs/promises";
 import * as path from "path";
+import * as os from "node:os";
 import ResourceUtil from "../util/resourceUtil.js";
 import encodeFilename from "filenamify";
 import { getLogger } from "@ui5/logger";
-import tempDir from "temp-dir";
 const log = getLogger("@ui5/task-adaptation::CacheHolder");
 export default class CacheHolder {
     static TEMP_TASK_DIR = "ui5-task-adaptation";
     static getTempDir(...paths) {
-        return path.join(tempDir, this.TEMP_TASK_DIR, ...paths.map(part => encodeFilename(part, { replacement: "_" })));
+        return path.join(os.tmpdir(), this.TEMP_TASK_DIR, ...paths.map(part => encodeFilename(part, { replacement: "_" })));
     }
     static read(repoName, token) {
         const directory = this.getTempDir(repoName, token);
         if (this.isValid(repoName, "repoName") && this.isValid(token, "token") && fs.existsSync(directory)) {
-            return ResourceUtil.read(directory);
+            return ResourceUtil.byGlob(directory, "**/*");
         }
+        return Promise.resolve(new Map());
     }
     static async write(repoName, token, files) {
         this.delete(repoName);
@@ -40,7 +41,7 @@ export default class CacheHolder {
      * Clears all cached files
      */
     static clear() {
-        this.deleteDir(path.join(tempDir, this.TEMP_TASK_DIR));
+        this.deleteDir(path.join(os.tmpdir(), this.TEMP_TASK_DIR));
     }
     static deleteDir(directory) {
         if (fs.existsSync(directory)) {
@@ -67,9 +68,10 @@ export function cached() {
     return function (_target, _propertyKey, descriptor) {
         const originalValue = descriptor.value;
         descriptor.value = async function (...args) {
-            let files = CacheHolder.read(args[0], args[1]);
+            let files = await CacheHolder.read(args[0], args[1]);
             CacheHolder.clearOutdatedExcept(args[0]);
-            if (files == null) {
+            if (files.size === 0) {
+                log.verbose(`Cache repo '${args[0]}' with token '${args[1]}' does not contain files. Fetching...`);
                 files = await originalValue.apply(this, args);
                 await CacheHolder.write(args[0], args[1], files);
             }

package/dist/index.js

@@ -6,6 +6,7 @@ import I18nMerger from "./util/i18nMerger.js";
 import ResourceUtil from "./util/resourceUtil.js";
 import { determineProcessor } from "./processors/processor.js";
 import FilesUtil from "./util/filesUtil.js";
+import PreviewManager from "./previewManager.js";
 /**
  * Creates an appVariant bundle from the provided resources.
  */
@@ -15,6 +16,7 @@ export default ({ workspace, options, taskUtil }) => {
         logBuilderVersion();
         const processor = determineProcessor(options.configuration);
         const adaptationProject = await AppVariant.fromWorkspace(workspace, options.projectNamespace);
+        const previewManagerPromise = PreviewManager.createFromRoot(adaptationProject.reference, processor);
         const appVariantIdHierarchy = await processor.getAppVariantIdHierarchy(adaptationProject.reference);
         if (appVariantIdHierarchy.length === 0) {
             throw new Error(`No app variant found for reference ${adaptationProject.reference}`);
@@ -43,7 +45,9 @@ export default ({ workspace, options, taskUtil }) => {
         files = FilesUtil.filter(files);
         files = FilesUtil.rename(files, references);
         adaptationProject.omitDeletedResources(files, options.projectNamespace, taskUtil);
-        const writePromises = new Array();
+        // Read libs for preview
+        const previewManager = await previewManagerPromise;
+        const writePromises = new Array(previewManager.processPreviewResources(files));
         files.forEach((content, filename) => {
             const resource = ResourceUtil.createResource(filename, options.projectNamespace, content);
             writePromises.push(workspace.write(resource));

package/dist/model/authenticationError.d.ts

@@ -0,0 +1,3 @@
+export default class AuthenticationError extends Error {
+    constructor(details?: string);
+}

package/dist/model/authenticationError.js

@@ -0,0 +1,8 @@
+export default class AuthenticationError extends Error {
+    constructor(details) {
+        super(details);
+        this.name = "AuthenticationError";
+        this.message = "Authentication error. Use 'cf login' to authenticate in Cloud Foundry" + (details ? `: ${details}` : ".");
+    }
+}
+//# sourceMappingURL=authenticationError.js.map

package/dist/model/types.d.ts

@@ -85,6 +85,18 @@ export interface IHTML5RepoInfo {
     token: string;
     baseUri: string;
 }
+export interface IReuseLibInfo {
+    name: string;
+    lazy: boolean;
+    html5AppHostId: string;
+    html5AppName: string;
+    html5AppVersion: string;
+    html5CacheBusterToken: string;
+    url: {
+        uri: string;
+        final: boolean;
+    };
+}
 export interface IAuth {
     username: string;
     password: string;

package/dist/previewManager.d.ts

@@ -0,0 +1,13 @@
+import IProcessor from "./processors/processor.js";
+export default class PreviewManager {
+    private readonly fetchLibsPromises;
+    static createFromRoot(appId: string, processor: IProcessor): Promise<PreviewManager>;
+    static isPreviewRequested(): boolean;
+    private constructor();
+    processPreviewResources(baseAppFiles: ReadonlyMap<string, string>): Promise<void>;
+    private preReadLibs;
+    private searchBaseAppXsAppJsonFile;
+    private mergeXsAppJsonFiles;
+    private static moveLibraryFiles;
+    private static modifyRoutes;
+}

package/dist/previewManager.js

@@ -0,0 +1,142 @@
+import { getLogger } from "@ui5/logger";
+import ResourceUtil from "./util/resourceUtil.js";
+import path from "path";
+const log = getLogger("@ui5/task-adaptation::PreviewManager");
+const REUSE_DIR = ".adp/reuse";
+const APP_INFO_FILE = "ui5AppInfo.json";
+const XS_APP_JSON_FILE = "xs-app.json";
+export default class PreviewManager {
+    fetchLibsPromises = new Map();
+    static async createFromRoot(appId, processor) {
+        let ui5AppInfo = "";
+        if (PreviewManager.isPreviewRequested()) {
+            try {
+                ui5AppInfo = await ResourceUtil.readInProject(APP_INFO_FILE);
+            }
+            catch (_err) {
+                log.verbose("Preview mode not requested (env variable ADP_BUILDER_MODE=preview is not set), skipping preview resources processing.");
+                throw new Error(`ui5AppInfo.json is missing in project root, cannot process preview resources.`);
+            }
+        }
+        return new PreviewManager(appId, ui5AppInfo, processor);
+    }
+    static isPreviewRequested() {
+        return process.env.ADP_BUILDER_MODE === "preview";
+    }
+    constructor(appId, ui5AppInfo, processor) {
+        // If no ui5AppInfo is provided, no preview processing is needed
+        if (!ui5AppInfo) {
+            return;
+        }
+        const appInfo = JSON.parse(ui5AppInfo)[appId];
+        if (!appInfo) {
+            throw new Error(`No app info found for original app id '${appId}' in ui5AppInfo.json`);
+        }
+        const reuseLibs = appInfo.asyncHints.libs.filter(lib => lib.html5AppHostId && lib.html5AppName && lib.html5AppVersion);
+        if (reuseLibs.length > 0) {
+            this.fetchLibsPromises = this.preReadLibs(reuseLibs, processor);
+        }
+        const logMap = {
+            Error: log.error,
+            Warning: log.warning,
+            Info: log.info,
+            debug: log.verbose
+        };
+        appInfo.messages.forEach((message) => {
+            const logger = logMap[message.severity] || log.info;
+            logger(`ui5AppInfo.json: ${message.severity} Message: ${message.message} (Error Code: ${message.errorCode})`);
+        });
+    }
+    async processPreviewResources(baseAppFiles) {
+        log.verbose(`Downloading reuse libraries to reuse folder`);
+        const xsAppFiles = new Map();
+        if (this.fetchLibsPromises.size === 0) {
+            log.verbose("No reuse libraries defined in ui5AppInfo.json for preview");
+            return;
+        }
+        const mergedFiles = new Map();
+        for (const [libName, libFilesPromise] of this.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) {
+                mergedFiles.set(filename, content);
+                if (filename.includes(XS_APP_JSON_FILE)) {
+                    xsAppFiles.set(filename, content);
+                }
+            }
+        }
+        this.searchBaseAppXsAppJsonFile(xsAppFiles, baseAppFiles);
+        this.mergeXsAppJsonFiles(xsAppFiles, mergedFiles);
+        await ResourceUtil.writeInProject(REUSE_DIR, mergedFiles);
+    }
+    preReadLibs(reuseLibs, processor) {
+        const promises = new Map();
+        reuseLibs.forEach(lib => {
+            log.info(`Downloading reuse library '${lib.html5AppName}' version '${lib.html5AppVersion}'`);
+            const promise = processor
+                .fetchReuseLib(lib.html5AppName, lib.html5CacheBusterToken, lib)
+                .then(libFiles => PreviewManager.moveLibraryFiles(libFiles, lib.html5AppName, lib.name));
+            promises.set(lib.html5AppName, promise);
+        });
+        return promises;
+    }
+    searchBaseAppXsAppJsonFile(xsAppFiles, baseAppFiles) {
+        const xsAppJsonContent = baseAppFiles.get(XS_APP_JSON_FILE);
+        if (xsAppJsonContent) {
+            xsAppFiles.set(XS_APP_JSON_FILE, xsAppJsonContent);
+        }
+        else {
+            log.warn("xs-app.json is missing in the downloaded base app files for preview");
+        }
+    }
+    mergeXsAppJsonFiles(xsAppFiles, files) {
+        // Start with empty xs-app.json
+        // welcomeFile is not needed for preview
+        const mergedXsAppJson = {
+            authenticationMethod: "none",
+            routes: []
+        };
+        xsAppFiles.forEach((xsAppInfoContent) => {
+            const xsAppInfo = JSON.parse(xsAppInfoContent);
+            if (mergedXsAppJson.authenticationMethod === "none" && xsAppInfo.authenticationMethod) {
+                mergedXsAppJson.authenticationMethod = xsAppInfo.authenticationMethod;
+            }
+            if (Array.isArray(xsAppInfo.routes)) {
+                mergedXsAppJson.routes = mergedXsAppJson.routes.concat(xsAppInfo.routes);
+            }
+        });
+        files.set(XS_APP_JSON_FILE, JSON.stringify(mergedXsAppJson, null, 2));
+    }
+    static 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_FILE)) {
+                content = PreviewManager.modifyRoutes(content, libraryName, libId);
+            }
+            files.set(newFilename, content);
+        });
+        return files;
+    }
+    ;
+    static 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: path.join(REUSE_DIR, libName)
+                };
+            }
+            return route;
+        });
+        return JSON.stringify(xsApp);
+    }
+}
+//# sourceMappingURL=previewManager.js.map

package/dist/processors/abapProcessor.d.ts

@@ -10,6 +10,7 @@ export default class AbapProcessor implements IProcessor {
     constructor(configuration: IConfiguration, abapRepoManager: AbapRepoManager, annotationManager: AnnotationManager);
     getAppVariantIdHierarchy(appId: string): Promise<IAppVariantIdHierarchyItem[]>;
     fetch(repoName: string, _cachebusterToken: string): Promise<Map<string, string>>;
+    fetchReuseLib(): Promise<Map<string, string>>;
     validateConfiguration(): void;
     updateLandscapeSpecificContent(baseAppManifest: any, baseAppFiles: Map<string, string>, appVariantId: string, prefix: string): Promise<void>;
     getConfigurationType(): string;

package/dist/processors/abapProcessor.js

@@ -22,6 +22,9 @@ export default class AbapProcessor {
     fetch(repoName, _cachebusterToken) {
         return this.abapRepoManager.fetch(repoName);
     }
+    fetchReuseLib() {
+        throw new Error("Preview is not available on SAP S/4HANA On-Premise or Cloud Systems. Please create a ticket on CA-UI5-FL-ADP-BAS component.");
+    }
     validateConfiguration() {
         // validate general app config
         const properties = ["appName"];

package/dist/processors/cfProcessor.d.ts

@@ -1,11 +1,12 @@
 import IAppInfo from "../model/appVariantIdHierarchyItem.js";
-import { IConfiguration } from "../model/types.js";
+import { IConfiguration, IReuseLibInfo } from "../model/types.js";
 import IProcessor from "./processor.js";
 export default class CFProcessor implements IProcessor {
     private configuration;
     constructor(configuration: IConfiguration);
     getAppVariantIdHierarchy(appId: string): Promise<IAppInfo[]>;
     fetch(_repoName: string, _cachebusterToken: string): Promise<Map<string, string>>;
+    fetchReuseLib(_libName: string, _cachebusterToken: string, lib: IReuseLibInfo): Promise<Map<string, string>>;
     validateConfiguration(): void;
     updateLandscapeSpecificContent(baseAppManifest: any, baseAppFiles: Map<string, string>): Promise<void>;
     private updateXsAppJson;

package/dist/processors/cfProcessor.js

@@ -9,6 +9,7 @@ import { cached } from "../cache/cacheHolder.js";
 import { validateObject } from "../util/commonUtil.js";
 import CFUtil from "../util/cfUtil.js";
 import { getLogger } from "@ui5/logger";
+import PreviewManager from "../previewManager.js";
 const log = getLogger("@ui5/task-adaptation::CFProcessor");
 export default class CFProcessor {
     configuration;
@@ -26,12 +27,18 @@ export default class CFProcessor {
     fetch(_repoName, _cachebusterToken) {
         return HTML5RepoManager.getBaseAppFiles(this.configuration);
     }
+    fetchReuseLib(_libName, _cachebusterToken, lib) {
+        return HTML5RepoManager.getReuseLibFiles(this.configuration, lib);
+    }
     validateConfiguration() {
         validateObject(this.configuration, ["appHostId", "appName", "appVersion"], "should be specified in ui5.yaml configuration");
     }
     async updateLandscapeSpecificContent(baseAppManifest, baseAppFiles) {
         this.updateCloudPlatform(baseAppManifest);
-        await this.updateXsAppJson(baseAppFiles);
+        // Preview uses destinations and does not require xs-app.json updates
+        if (!PreviewManager.isPreviewRequested()) {
+            await this.updateXsAppJson(baseAppFiles);
+        }
     }
     async updateXsAppJson(baseAppFiles) {
         const xsAppJsonContent = baseAppFiles.get("xs-app.json");
@@ -119,4 +126,7 @@ export default class CFProcessor {
 __decorate([
     cached()
 ], CFProcessor.prototype, "fetch", null);
+__decorate([
+    cached()
+], CFProcessor.prototype, "fetchReuseLib", null);
 //# sourceMappingURL=cfProcessor.js.map

package/dist/processors/processor.d.ts

@@ -1,8 +1,9 @@
 import IAppVariantIdHierarchyItem from "../model/appVariantIdHierarchyItem.js";
-import { IConfiguration } from "../model/types.js";
+import { IConfiguration, IReuseLibInfo } from "../model/types.js";
 export default interface IProcessor {
     getAppVariantIdHierarchy(appId: string): Promise<IAppVariantIdHierarchyItem[]>;
     fetch(repoName: string, cachebusterToken: string): Promise<Map<string, string>>;
+    fetchReuseLib(repoName: string, cachebusterToken: string, lib: IReuseLibInfo): Promise<Map<string, string>>;
     createAppVariantHierarchyItem(appVariantId: string, version: string): void;
     updateLandscapeSpecificContent(baseAppManifest: any, baseAppFiles: Map<string, string>, appVariantId: string, prefix: string): Promise<void>;
 }

package/dist/repositories/html5RepoManager.d.ts

@@ -1,11 +1,12 @@
-import { IConfiguration } from "./../model/types.js";
+import { IConfiguration, IReuseLibInfo } from "./../model/types.js";
 export default class HTML5RepoManager {
     static getBaseAppFiles(configuration: IConfiguration): Promise<Map<string, string>>;
     static getMetadata(configuration: IConfiguration): Promise<any>;
+    static getReuseLibFiles(configuration: IConfiguration, lib: IReuseLibInfo): Promise<Map<string, string>>;
     private static getHtml5RepoInfo;
     private static getHTML5Credentials;
     private static getToken;
     private static requestMetadata;
-    private static getBaseAppZipEntries;
+    private static getAppZipEntries;
     private static download;
 }

package/dist/repositories/html5RepoManager.js

@@ -6,12 +6,26 @@ const log = getLogger("@ui5/task-adaptation::HTML5RepoManager");
 export default class HTML5RepoManager {
     static async getBaseAppFiles(configuration) {
         const { token, baseUri } = await this.getHtml5RepoInfo(configuration);
-        return this.getBaseAppZipEntries(configuration, baseUri, token);
+        const app = {
+            appName: configuration.appName,
+            appVersion: configuration.appVersion,
+            appHostId: configuration.appHostId
+        };
+        return this.getAppZipEntries(app, baseUri, token);
     }
     static async getMetadata(configuration) {
         const { token, baseUri } = await this.getHtml5RepoInfo(configuration);
         return this.requestMetadata(configuration, baseUri, token);
     }
+    static async getReuseLibFiles(configuration, lib) {
+        const { token, baseUri } = await this.getHtml5RepoInfo(configuration);
+        const libAppData = {
+            appName: lib.html5AppName,
+            appVersion: lib.html5AppVersion,
+            appHostId: lib.html5AppHostId
+        };
+        return this.getAppZipEntries(libAppData, baseUri, token);
+    }
     static async getHtml5RepoInfo(configuration) {
         const spaceGuid = await CFUtil.getSpaceGuid(configuration?.space);
         const credentials = await this.getHTML5Credentials(spaceGuid);
@@ -65,10 +79,9 @@ export default class HTML5RepoManager {
         const metadata = await RequestUtil.get(uri, requestOptions);
         return metadata.find((item) => item.appHostId === appHostId && item.applicationName === appName && item.applicationVersion === appVersion);
     }
-    static async getBaseAppZipEntries(options, html5RepoBaseUri, token) {
-        const { appHostId, appName, appVersion } = options;
-        const uri = `${html5RepoBaseUri}/applications/content/${appName}-${appVersion}/`;
-        const zip = await this.download(token, appHostId, uri);
+    static async getAppZipEntries(app, html5RepoBaseUri, token) {
+        const uri = `${html5RepoBaseUri}/applications/content/${app.appName}-${app.appVersion}/`;
+        const zip = await this.download(token, app.appHostId, uri);
         return unzipZipEntries(zip);
     }
     static async download(token, appHostId, uri) {

package/dist/util/cfUtil.d.ts

@@ -15,7 +15,7 @@ export default class CFUtil {
     private static createServiceKey;
     private static deleteServiceKeyUnsafe;
     private static getServiceInstance;
-    static processErrors(json: any): void;
+    static processCfErrors(errors?: ICfError[]): void;
     static requestCfApi(url: string): Promise<IResource[]>;
     static getOAuthToken(): Promise<string>;
     private static cfExecute;
@@ -76,3 +76,10 @@ export default class CFUtil {
      */
     static getSpaceGuid(spaceGuid?: string): Promise<string>;
 }
+interface ICfError {
+    code: number;
+    title: string;
+    detail: string;
+    [key: string]: any;
+}
+export {};

package/dist/util/cfUtil.js

@@ -3,6 +3,7 @@ import { getSpaceGuidThrowIfUndefined } from "@sap/cf-tools/out/src/utils.js";
 import { Cli } from "@sap/cf-tools/out/src/cli.js";
 import { eFilters } from "@sap/cf-tools/out/src/types.js";
 import { getLogger } from "@ui5/logger";
+import AuthenticationError from "../model/authenticationError.js";
 const log = getLogger("@ui5/task-adaptation::CFUtil");
 export default class CFUtil {
     /**
@@ -103,19 +104,20 @@ export default class CFUtil {
             guid: service.guid
         }));
     }
-    static processErrors(json) {
-        if (json?.errors?.length > 0) {
-            const message = JSON.stringify(json.errors);
-            if (json?.errors?.some((e) => e.title === "CF-NotAuthenticated" || e.code === 10002)) {
-                throw new Error(`Authentication error. Use 'cf login' to authenticate in Cloud Foundry: ${message}`);
-            }
-            throw new Error(`Failed sending request to Cloud Foundry: ${message}`);
+    static processCfErrors(errors) {
+        if (!errors || errors.length === 0) {
+            return;
+        }
+        const authError = errors.find(e => e.title === "CF-NotAuthenticated" || e.code === 10002);
+        if (authError) {
+            throw new AuthenticationError(authError.detail);
         }
+        throw new Error(`Failed sending request to Cloud Foundry: ${JSON.stringify(errors)}`);
     }
     static async requestCfApi(url) {
         const response = await this.cfExecute(["curl", url]);
         const json = this.parseJson(response);
-        this.processErrors(json);
+        this.processCfErrors(json?.errors);
         const resources = json?.resources;
         const totalPages = json?.pagination?.total_pages;
         if (totalPages > 1) {
@@ -142,11 +144,17 @@ export default class CFUtil {
                     if (errorValues?.length > 0) {
                         log.verbose(this.errorsToString(errorValues));
                     }
+                    if (response.stdout === "\n") {
+                        throw new AuthenticationError();
+                    }
                     return response.stdout;
                 }
                 errors.add(response.error || response.stderr);
             }
             catch (error) {
+                if (error instanceof AuthenticationError) {
+                    throw error;
+                }
                 errors.add(error.message);
             }
         }

package/dist/util/movingHandler/changeFileMoveHandler.d.ts

@@ -0,0 +1,8 @@
+export declare const moveFiles: (inputFiles: ReadonlyMap<string, string>, prefix: string, id: string) => {
+    files: Map<string, string>;
+    renamingPaths: Map<string, string>;
+};
+export declare const moveFile: (filename: string, content: string, prefix: string, id: string) => {
+    newFilename: string;
+    renamingPath: Map<string, string>;
+};

package/dist/util/movingHandler/changeFileMoveHandler.js

@@ -0,0 +1,77 @@
+import path from "path";
+import { isManifestChange } from "../commonUtil.js";
+const EXT_DIR = "ext/";
+const CHANGES_DIR = "changes/";
+const nameSpaceRegex = new RegExp(`(?<=ControllerExtension.extend\\(")([^"]*)(?=")`);
+/**
+* 2p. We move to appVariantFolder (prefix) only files that go along the
+* change files, like js or fragments. Changes are renamed in resources,
+* packed in flexibility-bundle and removed.
+* @param filename - The filename relative to the root
+*/
+function shouldMove(filename, content) {
+    //TODO: is it more reliable to check change/fileType?
+    if (isManifestChange(filename, content)) {
+        return true;
+    }
+    return filename.startsWith(CHANGES_DIR) && [".change", ".variant", ".ctrl_variant", ".ctrl_variant_change", ".ctrl_variant_management_change"].every(ext => !filename.endsWith(ext))
+        || filename.startsWith(EXT_DIR);
+}
+/**
+ * For controller extension the namespace needs a prefix
+ * The namespace needs to be unique for clear identification
+ * If controller extension have the same namespace the last one will be used
+ * @param filename  - The filename relative to the root
+ * @returns
+ */
+function shouldNamespaceRenamed(filename) {
+    return filename.startsWith(CHANGES_DIR) && filename.endsWith(".js");
+}
+/**
+ * Returns path without first directory (which is usually "changes" or
+ * "ext") and without file extension. For example, for
+ * "changes/coding/FixingDay.js" it returns "coding/FixingDay", for
+ * "changes/customer_app_variant5/fragments/hello_world_fixing_day.fragment.xml"
+ * it returns
+ * "changes/customer_app_variant5/fragments/hello_world_fixing_day". We
+ * remove all extensions not to rename it with slashes instead of dots. And
+ * we also exclude "changes" or "ext" include the prefix after them and then
+ * the filename. Without 'changes' or 'ext' directory, we need to replace
+ * only rest: coding/FixingDay.js to app_var_id1/coding/FixingDay.js
+ * @param filename
+ * @returns
+ */
+function getPathWithoutExtensions(filename) {
+    const [_dir, ...rest] = filename.split("/");
+    const restWOExt = [...rest];
+    restWOExt[restWOExt.length - 1] = restWOExt[restWOExt.length - 1].split(".")[0];
+    return restWOExt.join("/");
+}
+export const moveFiles = (inputFiles, prefix, id) => {
+    const files = new Map();
+    let renamingPaths = new Map();
+    inputFiles.forEach((content, filename) => {
+        const { newFilename, renamingPath } = moveFile(filename, content, prefix, id);
+        files.set(newFilename, content);
+        renamingPaths = new Map([...renamingPaths, ...renamingPath]);
+    });
+    return { files, renamingPaths };
+};
+export const moveFile = (filename, content, prefix, id) => {
+    let newFilename = filename;
+    let renamingPath = new Map();
+    if (shouldMove(filename, content)) {
+        const [dir, ...rest] = filename.split("/");
+        newFilename = path.join(dir, prefix, rest.join("/"));
+        const restWOExtPath = getPathWithoutExtensions(filename);
+        renamingPath.set(restWOExtPath, path.join(prefix, restWOExtPath));
+    }
+    if (shouldNamespaceRenamed(filename)) {
+        const namespaceMatch = nameSpaceRegex.exec(content.trim());
+        const controllerExtensionPath = namespaceMatch ? namespaceMatch[0] : "";
+        const fileName = controllerExtensionPath.replace(id, "");
+        renamingPath.set(controllerExtensionPath, `${id}.${prefix}${fileName}`);
+    }
+    return { newFilename, renamingPath };
+};
+//# sourceMappingURL=changeFileMoveHandler.js.map

package/dist/util/resourceUtil.d.ts

@@ -3,11 +3,19 @@ export default class ResourceUtil {
     static relativeToRoot(resourcePath: string, projectNamespace?: string): string;
     static getResourcePath(projectNamespace?: string, ...paths: string[]): string;
     static write(dir: string, files: Map<string, string>): Promise<void[]>;
-    private static _read;
-    static read(folder: string): Map<string, string>;
+    static writeInProject(dir: string, files: Map<string, string>): Promise<void[]>;
+    static byGlob(dir: string, pattern: string, excludes?: string[]): Promise<Map<string, string>>;
+    static byGlobInProject(pattern: string, excludes?: string[]): Promise<Map<string, string>>;
+    static readInProject(filepath: string): Promise<string>;
     static getString(resource: any): Promise<string>;
     static getJson(resource: any): Promise<any>;
     static setString(resource: any, str: string): void;
+    /**
+     * Check whether a file or directory exists (non-throwing).
+     * @param filePath Absolute or relative path
+     * @returns true if the path exists, false if not
+     */
+    private static fileExists;
     static createResource(filename: string, projectNamespace: string, content: string): any;
-    static toFileMap(resources: ReadonlyArray<Resource>, projectNamespace: string): Promise<Map<string, string>>;
+    static toFileMap(resources: ReadonlyArray<Resource>, projectNamespace?: string): Promise<Map<string, string>>;
 }