@ui5/task-adaptation 1.6.6 → 1.6.8

package/dist/landscapeConfiguration.js

@@ -1,39 +1,31 @@
-import AbapAdapter from "./adapters/abapAdapter.js";
-import CFAdapter from "./adapters/cfAdapter.js";
-import PreviewAdapter from "./adapters/previewAdapter.js";
-import AbapRepository from "./repositories/abapRepository.js";
-import HTML5Repository from "./repositories/html5Repository.js";
-import LocalRepository from "./repositories/localRepository.js";
-import AbapAnnotationManager from "./annotations/abapAnnotationManager.js";
-import CFAnnotationManager from "./annotations/cfAnnotationManager.js";
 import CFValidator from "./util/validator/cfValidator.js";
-import AbapValidator from "./util/validator/abapValidator.js";
 import { isOneOf } from "./util/validator/validator.js";
 import { LANDSCAPE_TYPES } from "./model/configuration.js";
 import { getLogger } from "@ui5/logger";
+import AbapValidator from "./util/validator/abapValidator.js";
 import LocalAnnotationManager from "./annotations/localAnnotationManager.js";
 const log = getLogger("@ui5/task-adaptation::LandscapeConfiguration");
-export function initialize(configuration) {
-    const type = getTypeByConfiguration(configuration);
+export async function initialize(configuration, options = {}) {
+    const type = await getTypeByConfiguration(configuration);
     const enhancedConfig = { ...configuration, type };
-    const repository = getRepository(enhancedConfig);
-    const annotationManager = getAnnotationManager(enhancedConfig, repository);
+    const repository = await getRepository(enhancedConfig, options);
+    const annotationManager = await getAnnotationManager(enhancedConfig, repository);
     return {
-        adapter: getAdapter(enhancedConfig, annotationManager),
+        adapter: await getAdapter(enhancedConfig, annotationManager),
         repository,
         annotationManager
     };
 }
-function getTypeByConfiguration(configuration) {
-    const validators = [
-        new CFValidator(),
-        new AbapValidator(),
-    ];
+async function getTypeByConfiguration(configuration) {
     if (isOneOf(LANDSCAPE_TYPES, configuration.type)) {
         return configuration.type;
     }
     else {
         log.warn("Deprecated behavior: type is not specified or invalid. Should be either 'cf' or 'abap'. Trying to detect the type based on provided configuration");
+        const validators = [
+            new CFValidator(),
+            new AbapValidator(),
+        ];
         for (const validator of validators) {
             try {
                 validator.validateConfiguration(configuration);
@@ -46,41 +38,59 @@ function getTypeByConfiguration(configuration) {
         throw new Error("'type' should be specified in ui5.yaml configuration: 'cf' or 'abap'");
     }
 }
-function getAdapter(configuration, annotationManager) {
+async function getAdapter(configuration, annotationManager) {
     if (isPreview()) {
+        const { default: PreviewAdapter } = await import("./adapters/previewAdapter.js");
         return new PreviewAdapter(configuration);
     }
     switch (configuration.type) {
-        case "abap":
+        case "abap": {
+            const { default: AbapAdapter } = await import("./adapters/abapAdapter.js");
             return new AbapAdapter(annotationManager);
-        case "cf":
+        }
+        case "cf": {
+            const { default: CFAdapter } = await import("./adapters/cfAdapter.js");
             return new CFAdapter(configuration);
+        }
         default:
             throw new Error(`No adapter found for the given configuration type '${configuration.type}'`);
     }
 }
-function getRepository(configuration) {
+async function getRepository(configuration, options) {
+    if (options.useCacheRepository) {
+        const { default: CacheRepository } = await import("./repositories/cacheRepository.js");
+        return new CacheRepository(configuration);
+    }
     if (isLocal()) {
+        const { default: LocalRepository } = await import("./repositories/localRepository.js");
         return new LocalRepository();
     }
     switch (configuration.type) {
-        case "abap":
+        case "abap": {
+            const { default: AbapRepository } = await import("./repositories/abapRepository.js");
             return new AbapRepository(configuration);
-        case "cf":
+        }
+        case "cf": {
+            const { default: HTML5Repository } = await import("./repositories/html5Repository.js");
             return new HTML5Repository(configuration);
+        }
         default:
             throw new Error(`No repository found for the given configuration type '${configuration.type}'`);
     }
 }
-function getAnnotationManager(configuration, repository) {
+async function getAnnotationManager(configuration, repository) {
     if (isLocal()) {
         return new LocalAnnotationManager();
     }
     switch (configuration.type) {
-        case "abap":
+        case "abap": {
+            const { default: AbapAnnotationManager } = await import("./annotations/abapAnnotationManager.js");
             return new AbapAnnotationManager(configuration, repository);
-        case "cf":
+        }
+        case "cf": {
+            const { default: CFAnnotationManager } = await import("./annotations/cfAnnotationManager.js");
             return new CFAnnotationManager();
+        }
         default:
             throw new Error(`No annotation manager found for the given configuration type '${configuration.type}'`);
     }

package/dist/model/types.d.ts

@@ -22,6 +22,7 @@ export interface IGetServiceInstanceParams {
 export interface IServiceInstance {
     name: string;
     guid: string;
+    type?: string;
 }
 export interface IResource {
     name: string;
@@ -129,5 +130,8 @@ export type ServiceCredentials = {
     } | string>;
     "sap.cloud.service"?: string;
 };
-export type FetchFilesPromise = Map<string, Promise<ReadonlyMap<string, string>>>;
+export type FetchFilesPromise = Map<string, Promise<ReadonlyMap<string, Buffer>>>;
 export { IConfiguration };
+export interface IInitializeOptions {
+    useCacheRepository?: boolean;
+}

package/dist/repositories/abapProvider.js

@@ -1,11 +1,11 @@
 import { createAbapServiceProvider } from "@sap-ux/system-access";
 import { getLogger } from "@ui5/logger";
-import AbapValidator from "../util/validator/abapValidator.js";
+import AbapConnectionValidator from "../util/validator/abapConnectionValidator.js";
 const log = getLogger("@ui5/task-adaptation::AbapProvider");
 log.debug = (message) => log.verbose(message);
 export default class AbapProvider {
     provider = null;
-    abapValidator = new AbapValidator();
+    abapValidator = new AbapConnectionValidator();
     async get({ target, destination }) {
         if (!this.provider) {
             const abapTarget = this.abapValidator.validateAndGetAbapTarget(target, destination);

package/dist/repositories/abapRepository.d.ts

@@ -11,6 +11,6 @@ export default class AbapRepository implements IRepository {
     getAnnotationMetadata(uri: string): Promise<IMetadata>;
     downloadAnnotationFile(uri: string): Promise<Map<string, any>>;
     getMetadata(id: string): Promise<IMetadata>;
-    fetch(resource: IAbapResource): Promise<Map<string, string>>;
+    fetch(resource: IAbapResource): Promise<Map<string, Buffer>>;
 }
 export {};

package/dist/repositories/cacheRepository.d.ts

@@ -0,0 +1,10 @@
+import ICachedResource from "../cache/cachedResource.js";
+import { IConfiguration } from "../model/types.js";
+import IRepository from "./repository.js";
+export default class CacheRepository implements IRepository {
+    private configuration;
+    constructor(configuration: IConfiguration);
+    getAppVariantIdHierarchy(_appId: string): Promise<ICachedResource[]>;
+    fetch(resource: ICachedResource): Promise<Map<string, Buffer>>;
+    downloadAnnotationFile(uri: string): Promise<Map<string, string>>;
+}

package/dist/repositories/cacheRepository.js

@@ -0,0 +1,29 @@
+import CacheHolder from "../cache/cacheHolder.js";
+export default class CacheRepository {
+    configuration;
+    constructor(configuration) {
+        this.configuration = configuration;
+    }
+    async getAppVariantIdHierarchy(_appId) {
+        const { appName } = this.configuration;
+        if (!appName) {
+            throw new Error("previewManifest requires 'appName' in the ui5.yaml configuration");
+        }
+        return [{
+                appName,
+                cacheBusterToken: Promise.resolve("")
+            }];
+    }
+    async fetch(resource) {
+        const appName = resource.appName;
+        const cachedFiles = await CacheHolder.readLatest(appName);
+        if (cachedFiles.size === 0) {
+            throw new Error(`No cached base app found for '${appName}'. Please check the appName or run a full build first to populate the cache.`);
+        }
+        return cachedFiles;
+    }
+    downloadAnnotationFile(uri) {
+        throw new Error(`Download annotation file for uri: ${uri} is not available for CacheRepository.`);
+    }
+}
+//# sourceMappingURL=cacheRepository.js.map

package/dist/repositories/html5Repository.d.ts

@@ -10,7 +10,7 @@ export default class HTML5Repository implements IRepository {
     private validator;
     constructor(configuration: IConfiguration);
     getAppVariantIdHierarchy(_appId: string): Promise<IHtml5Resource[]>;
-    fetch(resource: IHtml5Resource): Promise<Map<string, string>>;
+    fetch(resource: IHtml5Resource): Promise<Map<string, Buffer>>;
     getMetadata(): Promise<any>;
     private getHtml5RepoInfo;
     private getHTML5Credentials;

package/dist/repositories/localRepository.d.ts

@@ -6,7 +6,7 @@ export interface ILocalResource extends ICachedResource {
 export default class LocalRepository implements IRepository {
     downloadAnnotationFile(_uri: string): Promise<Map<string, string>>;
     getAppVariantIdHierarchy(appId: string): Promise<ILocalResource[]>;
-    fetch(resource: ILocalResource): Promise<Map<string, string>>;
+    fetch(resource: ILocalResource): Promise<Map<string, Buffer>>;
     private buildManifestIndex;
     private getLocalFilesDir;
 }

package/dist/repositories/repository.d.ts

@@ -1,6 +1,6 @@
 import ICachedResource from "../cache/cachedResource.js";
 export default interface IRepository {
     getAppVariantIdHierarchy(appId: string): Promise<ICachedResource[]>;
-    fetch(resource: ICachedResource): Promise<Map<string, string>>;
+    fetch(resource: ICachedResource): Promise<Map<string, Buffer>>;
     downloadAnnotationFile(uri: string): Promise<Map<string, string>>;
 }

package/dist/util/cfUtil.d.ts

@@ -10,10 +10,9 @@ export default class CFUtil {
      */
     static getServiceInstanceKeys(getServiceInstanceParams: IGetServiceInstanceParams, createServiceInstanceParams?: ICreateServiceInstanceParams): Promise<IServiceKeys>;
     static createService(params: ICreateServiceInstanceParams): Promise<void>;
-    private static getOrCreateServiceKeys;
-    private static getServiceKeys;
+    private static getOrCreateCredentials;
+    private static fetchCredentials;
     private static createServiceKey;
-    private static deleteServiceKeyUnsafe;
     private static getServiceInstance;
     static processCfErrors(errors?: ICfError[]): void;
     static requestCfApi(url: string): Promise<IResource[]>;
@@ -22,14 +21,15 @@ export default class CFUtil {
     private static errorsToString;
     private static parseJson;
     /**
-     * Get service keys and return the first one with valid endpoints
+     * Return the most recently created service credential binding (key) for the given service instance,
+     * or undefined if no keys exist.
      * @private
      * @static
      * @param {string} serviceInstanceGuid the service instance guid
-     * @return {Promise<ServiceCredentials | null>} the first service key with valid endpoints, or null if none found
+     * @return {Promise<any | undefined>} the newest binding object ({ name, guid, created_at, … }) or undefined
      * @memberof CFUtil
      */
-    private static getServiceKeyWithValidEndpoints;
+    private static getNewestServiceKey;
     /**
      * Get service keys for a service instance by name. If the existing service key
      * has endpoints as strings instead of objects, a new service key will be created.
@@ -49,24 +49,6 @@ export default class CFUtil {
      * @memberof CFUtil
      */
     private static hasValidEndpoints;
-    /**
-     * Get all service key names for a service instance
-     * @private
-     * @static
-     * @param {string} serviceInstanceGuid the service instance guid
-     * @return {Promise<string[]>} promise with array of service key names
-     * @memberof CFUtil
-     */
-    private static getAllServiceKeyNames;
-    /**
-     * Generate a unique service key name in format serviceInstanceName-key-N
-     * @static
-     * @param {string} serviceInstanceName the service instance name
-     * @param {string} serviceInstanceGuid the service instance guid
-     * @return {Promise<string>} promise with unique service key name
-     * @memberof CFUtil
-     */
-    static generateUniqueServiceKeyName(serviceInstanceName: string, serviceInstanceGuid: string): Promise<string>;
     /**
      * Get space guid from configuration or local CF fodler
      * @static

package/dist/util/cfUtil.js

@@ -1,7 +1,6 @@
-import { cfCreateService, cfGetInstanceCredentials } from "@sap/cf-tools/out/src/cf-local.js";
+import { cfCreateService } from "@sap/cf-tools/out/src/cf-local.js";
 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");
@@ -25,12 +24,12 @@ export default class CFUtil {
         }
         // we can use any instance in the list to connect to HTML5 Repo
         log.verbose(`Use '${serviceInstances[0].name}' HTML5 Repo Runtime service instance`);
-        const serviceKeys = await this.getOrCreateServiceKeys(serviceInstances[0]);
-        if (!(serviceKeys?.length > 0)) {
+        const credentials = await this.getOrCreateCredentials(serviceInstances[0]);
+        if (!credentials) {
             throw new Error(`Cannot get service keys for '${getServiceInstanceParams.names?.join(", ")}' service in current space: ${getServiceInstanceParams.spaceGuids?.join(", ")}`);
         }
         return {
-            credentials: serviceKeys[0].credentials,
+            credentials,
             serviceInstance: serviceInstances[0]
         };
     }
@@ -52,27 +51,28 @@ export default class CFUtil {
             throw new Error(`Cannot create a service instance '${params.serviceInstanceName}' in space '${params.spaceGuid}': ${error.message}`);
         }
     }
-    static async getOrCreateServiceKeys(serviceInstance) {
-        const credentials = await this.getServiceKeys(serviceInstance.guid);
-        if (credentials.length === 0) {
+    static async getOrCreateCredentials(serviceInstance) {
+        if (serviceInstance.type === "user-provided") {
+            log.verbose(`Service instance '${serviceInstance.name}' is user-provided, fetching credentials directly`);
+            return this.fetchCredentials(`/v3/service_instances/${serviceInstance.guid}/credentials`);
+        }
+        let key = await this.getNewestServiceKey(serviceInstance.guid);
+        if (key == null) {
             const serviceKeyName = serviceInstance.name + "_key";
             log.info(`Creating service key '${serviceKeyName}' for service instance '${serviceInstance.name}'`);
             await this.createServiceKey(serviceInstance.name, serviceKeyName);
+            key = await this.getNewestServiceKey(serviceInstance.guid);
+            if (key == null) {
+                throw new Error(`Service key was created for '${serviceInstance.name}' but could not be retrieved`);
+            }
         }
-        else {
-            return credentials;
-        }
-        return this.getServiceKeys(serviceInstance.guid);
+        log.verbose(`Using service key '${key.name}' for service instance '${serviceInstance.name}'`);
+        return this.fetchCredentials(`/v3/service_credential_bindings/${key.guid}/details`);
     }
-    static getServiceKeys(serviceInstanceGuid) {
-        return cfGetInstanceCredentials({
-            filters: [{
-                    value: serviceInstanceGuid,
-                    key: eFilters.service_instance_guids
-                }]
-        }).catch((error) => {
-            throw new Error("Failed to get service credentials: " + error.message);
-        });
+    static async fetchCredentials(url) {
+        const parsed = this.parseJson(await this.cfExecute(["curl", url]));
+        this.processCfErrors(parsed?.errors);
+        return parsed.credentials;
     }
     static async createServiceKey(serviceInstanceName, serviceKeyName) {
         try {
@@ -82,12 +82,6 @@ export default class CFUtil {
             throw new Error(`Couldn't create a service key for instance: ${serviceInstanceName}: ${error}`);
         }
     }
-    static deleteServiceKeyUnsafe(serviceInstanceName, serviceKeyName) {
-        // Fire and forget - async delete without waiting for result or handling errors
-        this.cfExecute(["delete-service-key", serviceInstanceName, serviceKeyName, "-f"]).catch(() => {
-            // Ignore any errors - this is intentionally unsafe
-        });
-    }
     static async getServiceInstance(params) {
         const PARAM_MAP = {
             spaceGuids: "space_guids",
@@ -101,7 +95,8 @@ export default class CFUtil {
         const resources = await this.requestCfApi(uri);
         return resources.map((service) => ({
             name: service.name,
-            guid: service.guid
+            guid: service.guid,
+            type: service.type
         }));
     }
     static processCfErrors(errors) {
@@ -174,18 +169,21 @@ export default class CFUtil {
         }
     }
     /**
-     * Get service keys and return the first one with valid endpoints
+     * Return the most recently created service credential binding (key) for the given service instance,
+     * or undefined if no keys exist.
      * @private
      * @static
      * @param {string} serviceInstanceGuid the service instance guid
-     * @return {Promise<ServiceCredentials | null>} the first service key with valid endpoints, or null if none found
+     * @return {Promise<any | undefined>} the newest binding object ({ name, guid, created_at, … }) or undefined
      * @memberof CFUtil
      */
-    static async getServiceKeyWithValidEndpoints(serviceInstanceGuid) {
+    static async getNewestServiceKey(serviceInstanceGuid) {
         try {
-            const serviceKeys = await this.getServiceKeys(serviceInstanceGuid);
-            // Find and return the first key with valid endpoints
-            return serviceKeys.find((key) => key.credentials?.endpoints && this.hasValidEndpoints(key.credentials.endpoints));
+            const keyList = await this.requestCfApi(`/v3/service_credential_bindings?type=key&service_instance_guids=${serviceInstanceGuid}`);
+            if (!keyList?.length) {
+                return undefined;
+            }
+            return keyList.toSorted((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())[0];
         }
         catch (error) {
             throw new Error("Failed to get service credentials: " + error.message);
@@ -212,30 +210,11 @@ export default class CFUtil {
         }
         const serviceInstance = serviceInstances[0];
         log.verbose(`Found service instance '${serviceInstance.name}' with guid: ${serviceInstance.guid}`);
-        // If no valid service key found, create a new one with unique name
-        const uniqueServiceKeyNamePromise = this.generateUniqueServiceKeyName(serviceInstance.name, serviceInstance.guid);
-        // Get service keys with credentials to find any with valid endpoints:
-        // object with url and destination instead of a single url string
-        const validKey = await this.getServiceKeyWithValidEndpoints(serviceInstance.guid);
-        if (validKey) {
-            log.verbose(`Using existing service key with valid endpoints structure`);
-            return validKey.credentials;
-        }
-        const uniqueServiceKeyName = await uniqueServiceKeyNamePromise;
-        log.verbose(`No valid service key found with proper endpoints structure. Creating new service key '${uniqueServiceKeyName}' for '${serviceInstance.name}'`);
-        await this.createServiceKey(serviceInstance.name, uniqueServiceKeyName);
-        // Get the newly created service key and validate its endpoints
-        const newValidKey = await this.getServiceKeyWithValidEndpoints(serviceInstance.guid);
-        if (newValidKey) {
-            log.verbose(`Using newly created service key with valid endpoints structure`);
-            return newValidKey.credentials;
+        const credentials = await this.getOrCreateCredentials(serviceInstance);
+        if (!credentials?.endpoints || !this.hasValidEndpoints(credentials.endpoints)) {
+            log.info(`Service key for '${serviceInstance.name}' does not have endpoints with service urls for xs-app.json update`);
         }
-        // Clean up the created service key since it doesn't have valid
-        // endpoints. We don't throw an error here even if no valid endpoints
-        // found. We assume that there might be no coincidence between
-        // credential endpoints and xs-app.json destinations.
-        this.deleteServiceKeyUnsafe(serviceInstance.name, uniqueServiceKeyName);
-        log.verbose(`Created service key '${uniqueServiceKeyName}' does not have valid endpoints structure. Triggered deletion of invalid service key '${uniqueServiceKeyName}'`);
+        return credentials;
     }
     /**
      * Check if endpoints object has at least one property that is an object
@@ -252,42 +231,6 @@ export default class CFUtil {
         // Check if at least one property of endpoints is an object
         return Object.values(endpoints).some(value => value && typeof value === 'object' && !Array.isArray(value));
     }
-    /**
-     * Get all service key names for a service instance
-     * @private
-     * @static
-     * @param {string} serviceInstanceGuid the service instance guid
-     * @return {Promise<string[]>} promise with array of service key names
-     * @memberof CFUtil
-     */
-    static async getAllServiceKeyNames(serviceInstanceGuid) {
-        try {
-            const serviceKeys = await this.requestCfApi(`/v3/service_credential_bindings?type=key&service_instance_guids=${serviceInstanceGuid}`);
-            return serviceKeys.map((key) => key.name);
-        }
-        catch (error) {
-            throw new Error(`Failed to get service key names: ${error.message}`);
-        }
-    }
-    /**
-     * Generate a unique service key name in format serviceInstanceName-key-N
-     * @static
-     * @param {string} serviceInstanceName the service instance name
-     * @param {string} serviceInstanceGuid the service instance guid
-     * @return {Promise<string>} promise with unique service key name
-     * @memberof CFUtil
-     */
-    static async generateUniqueServiceKeyName(serviceInstanceName, serviceInstanceGuid) {
-        const existingKeyNames = await this.getAllServiceKeyNames(serviceInstanceGuid);
-        let counter = 0;
-        let keyName;
-        do {
-            keyName = `${serviceInstanceName}-key-${counter}`;
-            counter++;
-        } while (existingKeyNames.includes(keyName));
-        log.verbose(`Generated unique service key name: ${keyName}`);
-        return keyName;
-    }
     /**
      * Get space guid from configuration or local CF fodler
      * @static

package/dist/util/commonUtil.d.ts

@@ -2,6 +2,11 @@ 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 bufferToString(buffer: Buffer): string;
+export declare function bufferToJson(buffer: Buffer): any;
+export declare function bufferToNormalizedString(buffer: Buffer): string;
+export declare function stringToBuffer(value: string): Buffer;
+export declare function jsonToBuffer(json: any): Buffer;
 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;
 export declare function escapeRegex(update: string): string;
@@ -12,7 +17,7 @@ export declare function traverse(json: any, paths: string[], callback: (json: an
 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;
+export declare function isManifestChange(filename: string, content: Buffer): boolean;
 /**
  * 4p. Reference map contains searchTerm as key and replacement as value. Base
  * id and app variant ids are renamed to adaptation project id.

package/dist/util/commonUtil.js

@@ -9,6 +9,21 @@ const MANIFEST_CHANGE = "appdescr_";
 export function dotToUnderscore(value) {
     return value.replace(/\./g, "_");
 }
+export function bufferToString(buffer) {
+    return buffer.toString("utf8");
+}
+export function bufferToJson(buffer) {
+    return JSON.parse(bufferToString(buffer));
+}
+export function bufferToNormalizedString(buffer) {
+    return bufferToString(buffer).replaceAll("\r\n", "\n");
+}
+export function stringToBuffer(value) {
+    return Buffer.from(value, "utf8");
+}
+export function jsonToBuffer(json) {
+    return stringToBuffer(JSON.stringify(json));
+}
 export function validateConfiguration(options, properties) {
     validateObject(options, properties, "should be specified in ui5.yaml configuration");
 }
@@ -93,7 +108,7 @@ export function getUniqueName(existingNames, template) {
 }
 export function isManifestChange(filename, content) {
     if (filename.endsWith(CHANGES_EXT)) {
-        const change = JSON.parse(content);
+        const change = bufferToJson(content);
         return change.changeType?.startsWith(MANIFEST_CHANGE);
     }
     return false;

package/dist/util/fsUtil.d.ts

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

package/dist/util/fsUtil.js

@@ -5,11 +5,11 @@ export default class FsUtil {
      * Read the file by filepath from the project root (folder where 'webapp',
      * 'package.json', 'ui5.yaml' located).
      * @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.
+     * @returns A promise that resolves to the file content as a Buffer.
      */
-    static async readInProject(filepath, encoding) {
+    static async readInProject(filepath) {
         try {
-            return await fs.readFile(path.join(process.cwd(), filepath), encoding);
+            return await fs.readFile(path.join(process.cwd(), filepath));
         }
         catch (error) {
             const isProjectRoot = await FsUtil.fileExists(path.join(process.cwd(), "ui5.yaml"));
@@ -44,7 +44,7 @@ export default class FsUtil {
             const parentPath = entry.parentPath ?? entry.path; // node v20.11.0 fallback
             const entryPath = path.join(parentPath, entry.name);
             const relativeFilePath = path.relative(rootDirectory, entryPath).replaceAll("\\", "/");
-            const content = await fs.readFile(entryPath, "utf-8");
+            const content = await fs.readFile(entryPath);
             return [relativeFilePath, content];
         });
         return new Map(await Promise.all(fileReadTasks));

package/dist/util/manifestUtil.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns the SAPUI5 dependency ids (libs and components) declared under
+ * "sap.ui5"/dependencies of a parsed manifest. These point at other apps and
+ * must not be renamed, so callers add them to the renamer ignore list.
+ */
+export declare function getSAPUI5DependencyIds(manifest: any): string[];

package/dist/util/manifestUtil.js

@@ -0,0 +1,15 @@
+/**
+ * Returns the SAPUI5 dependency ids (libs and components) declared under
+ * "sap.ui5"/dependencies of a parsed manifest. These point at other apps and
+ * must not be renamed, so callers add them to the renamer ignore list.
+ */
+export function getSAPUI5DependencyIds(manifest) {
+    const dependencies = manifest?.["sap.ui5"]?.dependencies;
+    if (!dependencies) {
+        return [];
+    }
+    const libs = dependencies.libs ? Object.keys(dependencies.libs) : [];
+    const components = dependencies.components ? Object.keys(dependencies.components) : [];
+    return [...libs, ...components];
+}
+//# sourceMappingURL=manifestUtil.js.map

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

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