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

package/dist/util/cf/xsAppJsonUtil.js

@@ -1,5 +1,4 @@
 import { getLogger } from "@ui5/logger";
-import CFUtil from "../cfUtil.js";
 const log = getLogger("@ui5/task-adaptation::XSAppJsonUtil");
 export const XSAPP_JSON_FILENAME = "xs-app.json";
 /**
@@ -63,7 +62,7 @@ export function enhanceRoutes(serviceCredentials, baseRoutes) {
         return acc;
     }, {});
     return baseRoutes.map((route) => {
-        const endpointName = destinationToEndpoint[route.destination];
+        const endpointName = route.destination && destinationToEndpoint[route.destination];
         if (endpointName) {
             // There is a matching endpoint: remove destination and add endpoint/service
             const { destination: _destination, ...rest } = route;
@@ -79,22 +78,12 @@ export function enhanceRoutes(serviceCredentials, baseRoutes) {
         }
     });
 }
-export async function fetchCredentialsAndEnhanceRoutes(xsAppJson, { serviceInstanceName, space, appName }) {
-    if (!serviceInstanceName) {
-        throw new Error(`Service instance name must be specified in ui5.yaml configuration for app '${appName}'`);
+export async function fetchCredentialsAndEnhanceRoutes(xsAppJson, serviceCredentialsPromise) {
+    const serviceCredentials = await serviceCredentialsPromise;
+    if (!serviceCredentials) {
+        log.verbose(`No service credentials available. Skipping xs-app.json update.`);
+        return xsAppJson;
     }
-    let serviceCredentials;
-    try {
-        // Get valid service keys with proper endpoints structure
-        serviceCredentials = await CFUtil.getOrCreateServiceKeyWithEndpoints(serviceInstanceName, space);
-    }
-    catch (error) {
-        throw new Error(`Failed to get valid service keys for app '${appName}': ${error.message}`);
-    }
-    if (serviceCredentials) {
-        return enhanceRoutesWithEndpointAndService(xsAppJson, serviceCredentials);
-    }
-    log.info(`No endpoints found for app '${appName}'. xs-app.json will not be updated.`);
-    return xsAppJson;
+    return enhanceRoutesWithEndpointAndService(xsAppJson, serviceCredentials);
 }
 //# sourceMappingURL=xsAppJsonUtil.js.map

package/dist/util/commonUtil.d.ts

@@ -1,5 +1,6 @@
 import { IConfiguration } from "../model/types.js";
 import Language from "../model/language.js";
+import AppVariant from "../appVariant.js";
 export declare function dotToUnderscore(value: string): string;
 export declare function validateConfiguration<T extends object>(options: T, properties: Array<keyof T>): void;
 export declare function validateObject<T extends object>(options: T, properties: Array<keyof T>, message: string): void;
@@ -12,3 +13,8 @@ export declare function logBuilderVersion(): void;
 export declare function logBetaUsage(): void;
 export declare function getUniqueName(existingNames: string[], template: string): string;
 export declare function isManifestChange(filename: string, content: string): boolean;
+/**
+ * 4p. Reference map contains searchTerm as key and replacement as value. Base
+ * id and app variant ids are renamed to adaptation project id.
+ */
+export declare function getReferences(appVariants: AppVariant[], adaptationProjectId: string): Map<string, string>;

package/dist/util/commonUtil.js

@@ -98,4 +98,21 @@ export function isManifestChange(filename, content) {
     }
     return false;
 }
+/**
+ * 4p. Reference map contains searchTerm as key and replacement as value. Base
+ * id and app variant ids are renamed to adaptation project id.
+ */
+export function getReferences(appVariants, adaptationProjectId) {
+    const references = new Map();
+    appVariants.forEach((variant, i) => {
+        if (i === 0) {
+            references.set(variant.reference, adaptationProjectId);
+        }
+        if (variant.id !== adaptationProjectId) {
+            references.set(variant.id, adaptationProjectId);
+        }
+        variant.getRenamingForMovedFiles().forEach((value, key) => references.set(key, value));
+    });
+    return references;
+}
 //# sourceMappingURL=commonUtil.js.map

package/dist/util/fsUtil.d.ts

@@ -1,11 +1,10 @@
 export default class FsUtil {
-    static readInProject(filepath: string): Promise<string>;
+    static readInProject(filepath: string, encoding?: BufferEncoding): Promise<Buffer | string>;
     /**
      * 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 readFilesRecursively(rootDirectory: string): Promise<Map<string, string>>;
-    static exists(filePath: string): Promise<boolean>;
+    static readFilesRecursively(rootDirectory: string): Promise<Map<string, Buffer>>;
 }

package/dist/util/fsUtil.js

@@ -7,9 +7,9 @@ export default class FsUtil {
      * @param filepath The relative file path from the project root (e.g. 'ui5AppInfo.json').
      * @returns A promise that resolves to the file content as a string.
      */
-    static async readInProject(filepath) {
+    static async readInProject(filepath, encoding) {
         try {
-            return await fs.readFile(path.join(process.cwd(), filepath), "utf-8");
+            return await fs.readFile(path.join(process.cwd(), filepath), encoding);
         }
         catch (error) {
             const isProjectRoot = await FsUtil.fileExists(path.join(process.cwd(), "ui5.yaml"));
@@ -37,38 +37,17 @@ export default class FsUtil {
         }
     }
     static async readFilesRecursively(rootDirectory) {
-        const directoriesToScan = [rootDirectory];
-        const fileReadTasks = [];
-        while (directoriesToScan.length > 0) {
-            const currentDirectory = directoriesToScan.pop();
-            if (!currentDirectory) {
-                continue;
-            }
-            const entries = await fs.readdir(currentDirectory, { withFileTypes: true });
-            for (const entry of entries) {
-                const entryPath = path.join(currentDirectory, entry.name);
-                if (entry.isDirectory()) {
-                    directoriesToScan.push(entryPath);
-                }
-                else if (entry.isFile()) {
-                    fileReadTasks.push((async () => {
-                        const relativeFilePath = path.relative(rootDirectory, entryPath);
-                        const content = await fs.readFile(entryPath, "utf-8");
-                        return [relativeFilePath, content];
-                    })());
-                }
-            }
-        }
+        const entries = await fs.readdir(rootDirectory, { withFileTypes: true, recursive: true });
+        const fileReadTasks = entries
+            .filter(entry => entry.isFile())
+            .map(async (entry) => {
+            const parentPath = entry.parentPath ?? entry.path;
+            const entryPath = path.join(parentPath, entry.name);
+            const relativeFilePath = path.relative(rootDirectory, entryPath).replaceAll("\\", "/");
+            const content = await fs.readFile(entryPath);
+            return [relativeFilePath, content];
+        });
         return new Map(await Promise.all(fileReadTasks));
     }
-    static async exists(filePath) {
-        try {
-            await fs.access(filePath);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
 }
 //# sourceMappingURL=fsUtil.js.map

package/dist/util/renamingUtil.js

@@ -14,98 +14,66 @@ export function renameMap(content, references, ignoreInStrings) {
     if (ignoredReferenceKeys.length > 0) {
         log.info(`Ignored renaming: ${ignoredReferenceKeys.join(", ")}`);
     }
-    const searchTerms = [...references.keys()];
+    const searchTerms = [...references.keys()].filter(key => key.length > 0);
     if (!content || !searchTerms || searchTerms.length === 0) {
         return content;
     }
-    const dotToSlash = (str) => str.replaceAll(".", "\/");
-    // We don't want to replace in adaptation project ids
-    ignoreInStrings.push(...ignoreInStrings, ...ignoreInStrings.map(dotToSlash));
-    let start = 0;
-    while (true) {
-        // If we don't replace some strings in the content - we find all of them
-        // and then don't replace inside their start and end indices.
-        const ignoredStrings = ignoreInStrings.map(string => {
-            return findAllOccurrences(content, string, start).map(i => ({ start: i, end: i + string.length }));
-        }).filter(arr => arr.length > 0) || [];
-        // We find the next search index with dots and slashes. Then we replace
-        // the nearest one and start search again in the next loop step.
-        const indices = new Array();
-        for (const searchTerm of searchTerms) {
-            const searchTermSlash = dotToSlash(searchTerm);
-            indices.push({
-                i: content.indexOf(searchTerm, start),
-                replacement: references.get(searchTerm),
-                searchTerm
-            }, {
-                i: content.indexOf(searchTermSlash, start),
-                replacement: dotToSlash(references.get(searchTerm)),
-                searchTerm: searchTermSlash
-            });
+    const dotToSlash = (str) => str.replaceAll(".", "/");
+    const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    // Build replacement lookup: pattern → replacement string (both dot and slash variants).
+    // Empty keys are skipped to avoid infinite zero-width regex matches.
+    const replacementMap = new Map();
+    for (const term of searchTerms) {
+        if (!term) {
+            continue;
         }
-        const found = indices.filter(({ i }) => i > -1);
-        if (found.length === 0) {
-            return content;
+        const repl = references.get(term);
+        replacementMap.set(term, repl);
+        const slashTerm = dotToSlash(term);
+        if (slashTerm !== term) {
+            replacementMap.set(slashTerm, dotToSlash(repl));
         }
-        const inBetween = (intervals, i) => {
-            for (const interval of intervals) {
-                for (const { start, end } of interval) {
-                    if (i >= start && i <= end) {
-                        return { start, end };
-                    }
-                }
-            }
-        };
-        // If we found two strings with the same index, we take the longest one
-        // to replace, e.g.: app.variant and app.variant2 has the same index,
-        // but we don't want to replace the first one with customer.app.variant,
-        // otherwise we get customer.app.variant2, which we don't need. We need
-        // to replace the whole app.variant2 with customer.app.variant. 
-        const findCurrentReplace = (found) => {
-            const result = new Map();
-            for (const entry of found) {
-                const existing = result.get(entry.i);
-                if (!existing || entry.searchTerm.length >= existing.searchTerm.length) {
-                    result.set(entry.i, entry);
-                }
-            }
-            return [...result.values()].sort((a, b) => a.i - b.i)[0];
-        };
-        // Ignore if search is in i18n key: replace "id" in "{{id.key}}" with
-        // "customer.id" and we need only the next one in string
-        found.forEach(index => index.inBetween = inBetween(ignoredStrings, index.i));
-        // There might be a situation when we found something in ignored
-        // substrings and the index could be the nearest, but after that the
-        // next index might be the actual find to replace, so we first of all
-        // ignore all the ignored substring findings and get the next actual
-        // replacement. But if there are only ignored substrings found, we take
-        // the first one just to skip it and go further.
-        const currentReplace = findCurrentReplace(found);
-        if (currentReplace.inBetween) {
-            start = currentReplace.inBetween.end;
+    }
+    // Build deduplicated ignore set with slash variants
+    const ignoreSet = new Set();
+    for (const ignoredString of ignoreInStrings) {
+        if (ignoredString) {
+            ignoreSet.add(ignoredString);
+            ignoreSet.add(dotToSlash(ignoredString));
         }
-        else {
-            content = content.substring(0, currentReplace.i)
-                + currentReplace.replacement
-                + content.substring(currentReplace.i + currentReplace.searchTerm.length);
-            start = currentReplace.i + currentReplace.replacement.length;
+    }
+    // When a string appears in both replacementMap and ignoreSet, ignoreSet
+    // takes precedence — the match is skipped rather than replaced. Remove such
+    // keys from replacementMap so the intent is explicit instead of relying on
+    // runtime check order.
+    for (const ignored of ignoreSet) {
+        replacementMap.delete(ignored);
+    }
+    // Collect all unique patterns sorted by length descending (longest match first).
+    // V8 compiles alternation of literal strings into an Aho-Corasick automaton
+    // internally, giving us O(n + P + z) single-pass matching in native C++ code.
+    const allPatterns = new Set([...replacementMap.keys(), ...ignoreSet]);
+    const sorted = [...allPatterns].sort((a, b) => b.length - a.length);
+    const regex = new RegExp(sorted.map(escapeRegex).join("|"), "g");
+    // Single-pass: find all matches, skip ignored ones, batch-replace the rest
+    const parts = [];
+    let lastEnd = 0;
+    let m;
+    while ((m = regex.exec(content)) !== null) {
+        const matched = m[0];
+        if (ignoreSet.has(matched))
+            continue;
+        const replacement = replacementMap.get(matched);
+        if (replacement !== undefined) {
+            parts.push(content.substring(lastEnd, m.index));
+            parts.push(replacement);
+            lastEnd = m.index + matched.length;
         }
     }
+    parts.push(content.substring(lastEnd));
+    return parts.join("");
 }
 export function renameResources(files, search, replacement) {
     return new Map([...files].map(([filepath, content]) => [filepath, rename(content, search, replacement)]));
 }
-function findAllOccurrences(string, substring, start) {
-    if (!substring) {
-        return [];
-    }
-    const indices = [];
-    let index = start;
-    while ((index = string.indexOf(substring, index)) !== -1) {
-        indices.push(index);
-        index += substring.length; // shift from current finding
-    }
-    return indices;
-}
-;
 //# sourceMappingURL=renamingUtil.js.map

package/dist/util/resourceUtil.d.ts

@@ -1,14 +1,30 @@
+/**
+ * Extensions of files whose contents are processed by the adaptation
+ * pipeline as text. Anything outside this whitelist is treated as binary
+ * (e.g. images, fonts) and is saved to the workspace verbatim by WorkspaceManager.
+ *
+ * Kept in sync with EXTENSIONS_TO_PROCESS in appVariant.ts.
+ */
+export declare const TEXT_EXTENSIONS: ReadonlySet<string>;
 export default class ResourceUtil {
     static getRootFolder(projectNamespace?: string): string;
     static relativeToRoot(resourcePath: string, projectNamespace?: string): string;
     static getResourcePath(projectNamespace?: string, ...paths: string[]): string;
-    static write(dir: string, files: Map<string, string>): Promise<void[]>;
-    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 write(dir: string, files: Map<string, Buffer>): Promise<void[]>;
+    static writeInProject(dir: string, files: Map<string, Buffer>): Promise<void[]>;
+    static byGlob(dir: string, pattern: string, excludes?: string[]): Promise<Map<string, Buffer>>;
+    static byGlobInProject(pattern: string, excludes?: string[]): Promise<Map<string, Buffer>>;
     static getString(resource: any): Promise<string>;
     static getJson(resource: any): Promise<any>;
     static setString(resource: any, str: string): void;
-    static createResource(filename: string, projectNamespace: string, content: string): any;
+    static createResource(filename: string, projectNamespace: string, content: string | Buffer): any;
+    private static createResourceFromContent;
     static toFileMap(resources: ReadonlyArray<Resource>, projectNamespace?: string): Promise<Map<string, string>>;
+    /**
+     * Decodes the text-extension files of a buffer map to UTF-8 strings.
+     * Binary files (e.g. images, fonts) are dropped — they are expected to
+     * have been written to the workspace separately and are not relevant
+     * to the in-memory text pipeline.
+     */
+    static toTextMap(buffers: ReadonlyMap<string, Buffer>): ReadonlyMap<string, string>;
 }

package/dist/util/resourceUtil.js

@@ -1,6 +1,30 @@
 import * as resourceFactory from "@ui5/fs/resourceFactory";
 import { posix as path } from "path";
 const UTF8 = "utf8";
+/**
+ * Extensions of files whose contents are processed by the adaptation
+ * pipeline as text. Anything outside this whitelist is treated as binary
+ * (e.g. images, fonts) and is saved to the workspace verbatim by WorkspaceManager.
+ *
+ * Kept in sync with EXTENSIONS_TO_PROCESS in appVariant.ts.
+ */
+export const TEXT_EXTENSIONS = new Set([
+    "js",
+    "json",
+    "xml",
+    "html",
+    "properties",
+    "change",
+    "appdescr_variant",
+    "ctrl_variant",
+    "ctrl_variant_change",
+    "ctrl_variant_management_change",
+    "variant",
+    "fioriversion",
+    "codeChange",
+    "xmlViewChange",
+    "context",
+]);
 export default class ResourceUtil {
     static getRootFolder(projectNamespace) {
         const newPath = ["/resources"];
@@ -21,7 +45,7 @@ export default class ResourceUtil {
      * NOTE: to write in project folder (folder where 'webapp',
      * 'package.json', 'ui5.yaml' located), use writeInProject method.
      * @param dir The directory to write files to.
-     * @param files A Map of file paths and their contents.
+     * @param files A Map of file paths and their contents as Buffer.
      * @returns A promise that resolves when all files have been written.
      */
     static write(dir, files) {
@@ -30,8 +54,8 @@ export default class ResourceUtil {
             virBasePath: "/"
         });
         const promises = [];
-        files.forEach((string, filename) => {
-            const resource = resourceFactory.createResource({ path: "/" + filename, string });
+        files.forEach((content, filename) => {
+            const resource = ResourceUtil.createResourceFromContent("/" + filename, content);
             promises.push(fsTarget.write(resource));
         });
         return Promise.all(promises);
@@ -40,7 +64,7 @@ export default class ResourceUtil {
      * Write files to the project folder (folder where 'webapp',
      * 'package.json', 'ui5.yaml' located), use writeInProject method.
      * @param dir The directory to write files to.
-     * @param files A Map of file paths and their contents.
+     * @param files A Map of file paths and their contents as Buffer.
      * @returns A promise that resolves when all files have been written.
      */
     static writeInProject(dir, files) {
@@ -53,7 +77,7 @@ export default class ResourceUtil {
      * @param dir The directory to search in.
      * @param pattern The glob pattern to match files, e.g., "/ui5AppInfo.json".
      * @param excludes An array of glob patterns to exclude from the search.
-     * @returns A promise that resolves to a Map of file paths and their contents.
+     * @returns A promise that resolves to a Map of file paths and their contents as Buffer.
      */
     static byGlob(dir, pattern, excludes = []) {
         const adapter = resourceFactory.createAdapter({
@@ -68,7 +92,7 @@ export default class ResourceUtil {
      * 'package.json', 'ui5.yaml' located), excluding specified glob patterns.
      * @param pattern The glob pattern to match files, e.g., "/ui5AppInfo.json".
      * @param excludes An array of glob patterns to exclude from the search.
-     * @returns A promise that resolves to a Map of file paths and their contents.
+     * @returns A promise that resolves to a Map of file paths and their contents as Buffer.
      */
     static byGlobInProject(pattern, excludes = []) {
         return ResourceUtil.byGlob("./", pattern, [
@@ -78,7 +102,7 @@ export default class ResourceUtil {
         ].concat(excludes));
     }
     static getString(resource) {
-        return resource.getBuffer().then((buffer) => buffer.toString(UTF8));
+        return resource.getBuffer().then((buffer) => buffer.toString(UTF8).replaceAll("\r\n", "\n"));
     }
     static getJson(resource) {
         return resource.getBuffer().then((buffer) => JSON.parse(buffer.toString(UTF8)));
@@ -87,10 +111,12 @@ export default class ResourceUtil {
         resource.setBuffer(Buffer.from(str, UTF8));
     }
     static createResource(filename, projectNamespace, content) {
-        return resourceFactory.createResource({
-            path: this.getResourcePath(projectNamespace, filename),
-            string: content
-        });
+        return ResourceUtil.createResourceFromContent(this.getResourcePath(projectNamespace, filename), content);
+    }
+    static createResourceFromContent(resourcePath, content) {
+        return resourceFactory.createResource(Buffer.isBuffer(content)
+            ? { path: resourcePath, buffer: content }
+            : { path: resourcePath, string: content });
     }
     static async toFileMap(resources, projectNamespace) {
         const files = new Map();
@@ -100,5 +126,20 @@ export default class ResourceUtil {
         }
         return files;
     }
+    /**
+     * Decodes the text-extension files of a buffer map to UTF-8 strings.
+     * Binary files (e.g. images, fonts) are dropped — they are expected to
+     * have been written to the workspace separately and are not relevant
+     * to the in-memory text pipeline.
+     */
+    static toTextMap(buffers) {
+        const text = new Map();
+        buffers.forEach((buffer, filename) => {
+            if (TEXT_EXTENSIONS.has(path.extname(filename).slice(1))) {
+                text.set(filename, buffer.toString(UTF8));
+            }
+        });
+        return text;
+    }
 }
 //# sourceMappingURL=resourceUtil.js.map

package/dist/util/validator/abapConnectionValidator.d.ts

@@ -0,0 +1,5 @@
+import { AbapTarget } from "@sap-ux/system-access";
+import { IAbapTargetMeta } from "../../model/configuration.js";
+export default class AbapConnectionValidator {
+    validateAndGetAbapTarget(target: AbapTarget & IAbapTargetMeta | undefined, destination: string | undefined): AbapTarget & IAbapTargetMeta;
+}

package/dist/util/validator/abapConnectionValidator.js

@@ -0,0 +1,22 @@
+import { validateObject } from "../commonUtil.js";
+import { isAppStudio } from "@sap-ux/btp-utils";
+import { getLogger } from "@ui5/logger";
+const log = getLogger("@ui5/task-adaptation::AbapConnectionValidator");
+export default class AbapConnectionValidator {
+    validateAndGetAbapTarget(target, destination) {
+        if (target) {
+            // if target configuration appears, we validate that it should be
+            // either target/destination for BAS or target/url for IDE we're
+            // trying to detect is it destination for BAS or url for IDE
+            const abapTargetProperties = isAppStudio() ? ["destination"] : ["url"];
+            validateObject(target, abapTargetProperties, "should be specified in ui5.yaml configuration/target");
+            return target;
+        }
+        else if (destination) {
+            log.warn("Destination is deprecated, use target/destination configuration instead");
+            return { destination };
+        }
+        throw new Error("Target should be specified in ui5.yaml configuration to connect the ABAP system");
+    }
+}
+//# sourceMappingURL=abapConnectionValidator.js.map

package/dist/util/validator/abapValidator.d.ts

@@ -1,8 +1,6 @@
-import { AbapTarget } from "@sap-ux/system-access";
-import { IAbapTargetMeta, IConfiguration, LandscapeType } from "../../model/configuration.js";
+import { IConfiguration, LandscapeType } from "../../model/configuration.js";
 import IValidator from "./validator.js";
 export default class AbapValidator implements IValidator {
     type: LandscapeType;
-    validateAndGetAbapTarget(target: AbapTarget & IAbapTargetMeta | undefined, destination: string | undefined): AbapTarget & IAbapTargetMeta;
-    validateConfiguration({ target, destination }: IConfiguration): void;
+    validateConfiguration({ destination, target }: IConfiguration): void;
 }

package/dist/util/validator/abapValidator.js

@@ -1,26 +1,14 @@
-import { validateObject } from "../commonUtil.js";
-import BtpUtils from "@sap-ux/btp-utils";
 import { getLogger } from "@ui5/logger";
 const log = getLogger("@ui5/task-adaptation::AbapValidator");
 export default class AbapValidator {
     type = "abap";
-    validateAndGetAbapTarget(target, destination) {
-        if (target) {
-            // if target configuration appears, we validate that it should be
-            // either target/destination for BAS or target/url for IDE we're
-            // trying to detect is it destination for BAS or url for IDE
-            const abapTargetProperties = BtpUtils.isAppStudio() ? ["destination"] : ["url"];
-            validateObject(target, abapTargetProperties, "should be specified in ui5.yaml configuration/target");
-            return target;
+    validateConfiguration({ destination, target }) {
+        if (!destination && !target) {
+            throw new Error("'target' should be specified in ui5.yaml configuration");
         }
-        else if (destination) {
+        else if (destination && !target) {
             log.warn("Destination is deprecated, use target/destination configuration instead");
-            return { destination };
         }
-        throw new Error("Target should be specified in ui5.yaml configuration to connect the ABAP system");
-    }
-    validateConfiguration({ target, destination }) {
-        this.validateAndGetAbapTarget(target, destination);
     }
 }
 //# sourceMappingURL=abapValidator.js.map

package/dist/util/validator/validator.d.ts

@@ -4,3 +4,4 @@ export default interface IValidator {
     validateConfiguration(configuration: IConfiguration): void;
 }
 export declare function isOneOf<T extends readonly unknown[]>(values: T, value: unknown): value is T[number];
+export declare function validateAppId(id: string): void;

package/dist/util/validator/validator.js

@@ -1,4 +1,15 @@
 export function isOneOf(values, value) {
     return values.includes(value);
 }
+export function validateAppId(id) {
+    if (!id) {
+        throw new Error(`The application id must not be empty.`);
+    }
+    // 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.
+    if (id.split(".").filter(Boolean).length < 2) {
+        throw new Error(`The application id '${id}' must have at least two parts, separated by a period.`);
+    }
+}
 //# sourceMappingURL=validator.js.map

package/dist/util/workspaceManager.d.ts

@@ -0,0 +1,9 @@
+export default class WorkspaceManager {
+    private readonly workspace;
+    private readonly projectNamespace;
+    private snapshot;
+    constructor(workspace: IWorkspace, projectNamespace: string);
+    createSnapshot(): Promise<void>;
+    restoreSnapshot(): Promise<void>;
+    saveAndConvert(buffersPromise: Promise<ReadonlyMap<string, Buffer>>): Promise<ReadonlyMap<string, string>>;
+}

package/dist/util/workspaceManager.js

@@ -0,0 +1,46 @@
+import ResourceUtil, { TEXT_EXTENSIONS } from "./resourceUtil.js";
+import { posix as path } from "path";
+const UTF8 = "utf8";
+export default class WorkspaceManager {
+    workspace;
+    projectNamespace;
+    snapshot;
+    constructor(workspace, projectNamespace) {
+        this.workspace = workspace;
+        this.projectNamespace = projectNamespace;
+    }
+    async createSnapshot() {
+        const resources = await this.workspace.byGlob("/**/*");
+        const rootFolderLength = ResourceUtil.getRootFolder(this.projectNamespace).length;
+        const entries = await Promise.all(resources.map(async (resource) => {
+            const filename = resource.getPath().substring(rootFolderLength + 1);
+            return [filename, await resource.getBuffer()];
+        }));
+        this.snapshot = new Map(entries);
+    }
+    async restoreSnapshot() {
+        if (!this.snapshot) {
+            throw new Error("No snapshot to restore — call createSnapshot() first");
+        }
+        const writes = [];
+        this.snapshot.forEach((buffer, filename) => {
+            const resource = ResourceUtil.createResource(filename, this.projectNamespace, buffer);
+            writes.push(this.workspace.write(resource));
+        });
+        await Promise.all(writes);
+    }
+    async saveAndConvert(buffersPromise) {
+        const buffers = await buffersPromise;
+        const writes = [];
+        const text = new Map();
+        buffers.forEach((buffer, filename) => {
+            if (TEXT_EXTENSIONS.has(path.extname(filename).slice(1))) {
+                text.set(filename, buffer.toString(UTF8));
+            }
+            writes.push(this.workspace.write(ResourceUtil.createResource(filename, this.projectNamespace, buffer)));
+        });
+        await Promise.all(writes);
+        return text;
+    }
+}
+//# sourceMappingURL=workspaceManager.js.map

package/dist/util/zipUtil.d.ts

@@ -1 +1 @@
-export declare function unzipZipEntries(zip: Buffer): Promise<Map<string, string>>;
+export declare function unzipZipEntries(zip: Buffer): Promise<Map<string, Buffer>>;

package/dist/util/zipUtil.js

@@ -11,6 +11,6 @@ export async function unzipZipEntries(zip) {
     }
 }
 function mapEntries(entries) {
-    return new Map(entries.filter(entry => !entry.isDirectory).map(entry => [entry.entryName, entry.getData().toString("utf8")]));
+    return new Map(entries.filter(entry => !entry.isDirectory).map(entry => [entry.entryName, entry.getData()]));
 }
 //# sourceMappingURL=zipUtil.js.map